ectags.el

   1 ;;; ectags-select.el --- Select from multiple tags
   2
   3 ;; Copyright (C) 2007  Scott Frazer and (C) 2008 John Connors
   4
   5 ;; Author: John Connors <johnc@yagc.ndo.co.uk>
   6 ;; Author: Scott Frazer <frazer.scott@gmail.com>
   7 ;; Maintainer: John Connors <johnc@yagc.ndo.co.uk>
   8 ;;
   9 ;; Keywords: exuberant-ctags ectags tag select
  10
  11 ;; This file is free software; you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation; either version 2, or (at your option)
  14 ;; any later version.
  15
  16 ;; This file is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs; see the file COPYING.  If not, write to
  23 ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  24 ;; Boston, MA 02110-1301, USA.
  25
  26 ;;; Commentary:
  27
  28
  29 ;; Reworking of etags-select to work with exuberant-ctags and eldoc.
  30 ;; ectags-tag-directory will generate a tag file in the current directory
  31 ;; with the specified language using exuberant-ctags extended tag format
  32 ;; which contains useful information about the current tag such as
  33 ;; the signature, it's parent class, which class it is a member of. Eldoc
  34 ;; displays this information. At present it does not do a very good job
  35 ;; of finding the best candidate tag in an OO language where there may
  36 ;; be multiple tags with the same name. It tries, however. The tag file
  37 ;; needs to be in a specific format, hence the ectags-tag-directory-command.
  38 ;; ectags-visit-tags-table is used to load in a tag table.
  39
  40 ;; Open a buffer with file/lines of exact-match tags shown.  Select one by
  41 ;; going to a line and pressing return.  pop-tag-mark still works with this
  42 ;; code.
  43 ;;
  44 ;;
  45 ;; An up to date version of this code lives on repo.or.cz
  46 ;; at git://repo.or.cz/ectags.git
  47
  48 ;;; Code:
  49
  50 ;
  51 ;; TO DO : tag completion DONE
  52 ;; TO DO : tags search DONE
  53 ;; TO DO : eldoc integration DONE
  54 ;; TO DO : more than one lang per dir DONE
  55 ;; TO DO : compile window for ectags DONE
  56 ;; TO DO : do sthing about ginormous tag files
  57 ;; TO DO : .. use abbreviated info
  58 ;; TO DO : .. use gzipped tag files
  59 ;; TO DO : use search for locating tag rather than line #
  60 ;; TO DO : some kind of higlighting for select buffer WHY DOESN'T IT WORK!?
  61 ;; TO DO : include line matched when searching for references
  62 ;; TO DO : investigate CEDET to see if it can guide eldoc to a better
  63 ;;        match for the  tag under the cursor
  64
  65 (require 'cl)
  66 (require 'custom)
  67 (require 'easymenu)
  68
  69 ;; Asm      *.asm *.ASM *.s *.S *.A51 *.29[kK] *.[68][68][kKsSxX] *.[xX][68][68]
  70 ;; Asp      *.asp *.asa
  71 ;; Awk      *.awk *.gawk *.mawk
  72 ;; BETA     *.bet
  73 ;; C        *.c
  74 ;; C++      *.c++ *.cc *.cp *.cpp *.cxx *.h *.h++ *.hh *.hp *.hpp *.hxx *.C *.H
  75 ;; C#       *.cs
  76 ;; Cobol    *.cbl *.cob *.CBL *.COB
  77 ;; Eiffel   *.e
  78 ;; Erlang   *.erl *.ERL *.hrl *.HRL
  79 ;; Fortran  *.f *.for *.ftn *.f77 *.f90 *.f95 *.F *.FOR *.FTN *.F77 *.F90 *.F95
  80 ;; HTML     *.htm *.html
  81 ;; Java     *.java
  82 ;; JavaScript *.js
  83 ;; Lisp     *.cl *.clisp *.el *.l *.lisp *.lsp *.ml
  84 ;; Lua      *.lua
  85 ;; Make     *.mak *.mk [Mm]akefile
  86 ;; Pascal   *.p *.pas
  87 ;; Perl     *.pl *.pm *.plx *.perl
  88 ;; PHP      *.php *.php3 *.phtml
  89 ;; Python   *.py *.python
  90 ;; REXX     *.cmd *.rexx *.rx
  91 ;; Ruby     *.rb *.ruby
  92 ;; Scheme   *.SCM *.SM *.sch *.scheme *.scm *.sm
  93 ;; Sh       *.sh *.SH *.bsh *.bash *.ksh *.zsh
  94 ;; SLang    *.sl
  95 ;; SML      *.sml *.sig
  96 ;; SQL      *.sql
  97 ;; Tcl      *.tcl *.tk *.wish *.itcl
  98 ;; Vera     *.vr *.vri *.vrh
  99 ;; Verilog  *.v
 100 ;; Vim      *.vim
 101 ;; YACC     *.y
 102
 103 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 104 ;;; Custom stuff
 105
 106
 107 ;;;###autoload
 108 (defgroup ectags nil
 109   "Exuberant Ctags Support for Emacs"
 110   :version "22.1.1"
 111   :group 'tools)
 112
 113 ;;;###autoload
 114 (defcustom ectags-command "ectags"
 115   "Name of the exuberant ctags executable on your system"
 116   :type 'string
 117   :group 'ectags)
 118
 119 ;;;###autoload
 120 (defcustom ectags-config-file "~/.ectags"
 121   "Name of the exuberant-ctags configuration file."
 122   :type 'string
 123   :group 'ectags)
 124
 125 ;;;###autoload
 126 (defcustom ectags-language-file-suffix-alist
 127   '(( "asp"    .  ( "*.asp" "*.asa" ))
 128     ( "awk"    .  ( "*.awk" "*.gawk" "*.mawk"))
 129     ( "c"      .  ( "*.c" "*.h" ))
 130     ( "c++"    .  ( "*.c++" "*.cc" "*.cp" "*.cpp"  "*.cxx" "*.h" "*.h++" "*.hh" "*.hp" "*.hpp" "*.hxx" "*.c"  "*.C" "*.h" "*.H"))
 131     ( "c#"     .  ( "*.cs" ))
 132     ( "java"   .  ( "*.java " ))
 133     ( "lisp"   .  (  "*.cl" "*.clisp" "*.el" "*.l" "*.lisp" "*.lsp" "*.ml"))
 134     ( "python" .  ( "*.py" "*.python" ))
 135     ( "SQL"    .  (  "*.sql" ))
 136     ( "Tcl"    .  ( "*.tcl" "*.tk" "*.wish" "*.itcl" )))
 137   "Association list defining file masks for languages"
 138   :type 'alist
 139   :group 'ectags)
 140
 141 ;;;###autoload
 142 (defcustom ectags-system-tag-table-list nil
 143   "List of tags tables that include system headers"
 144   :type 'list
 145   :group 'ectags)
 146
 147 ;;;###autoload
 148 (defcustom ectags-api-files
 149   '(( "wx"    .  "/usr/local/include/wx" )
 150     ( "gtk"    .  "/usr/include/gtk-2.0" )
 151     ( "glib"      . "/usr/include/glib-2.0" ))
 152   "Association list mapping apis to directories"
 153   :type 'alist
 154   :group 'ectags)
 155
 156
 157 ;;;###autoload
 158 (defcustom ectags-select-mode-hook nil
 159   "*List of functions to call on entry to ectags-select-mode mode."
 160   :group 'ectags
 161   :type 'hook)
 162
 163 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 164 ;;; Variables
 165
 166 (defvar *ectags-matches* nil
 167   "List of candiate tag matches")
 168
 169 (defvar *ectags-regexp* nil
 170   "Holds regexp currently being sought in tags")
 171
 172 (defvar *ectags-max-candidates* 7
 173   "How many candidates to select between")
 174
 175 (defvar *ectags-case-sensitive* t
 176   "Is the tag matching case sensitive?")
 177
 178 (defvar *ectags-autopop-tag* t
 179   "If non-nil, automatically pop the tag off the tag stack when jumped to")
 180
 181 (defvar *ectags-tag-stack* nil
 182   "Stack of tag positions for browsing.")
 183
 184 (defvar *ectags-obarray* nil
 185   "Obarray used for ectags completions.")
 186
 187 (defvar *ectags-select-buffer-name* "*ectags-select*"
 188   "ectags-select buffer name.")
 189
 190 (defvar *ectags-reference-buffer-name* "*ectag References*"
 191   "ectags-reference buffer-name")
 192
 193
 194 (defvar ectags-select-mode-font-lock-keywords nil
 195   "ectags-select font-lock-keywords.")
 196
 197 (defvar *ectags-select-source-buffer* nil
 198   "ectags-select source buffer tag was found from.")
 199
 200 (defvar *ectags-reference-source-buffer* nil
 201   "ectags-reference source buffer tag was found from.")
 202
 203 (defvar *ectags-select-opened-window* nil
 204   "ectags-select opened a select window.")
 205
 206 (defvar *ectags-reference-opened-window* nil
 207   "ectags-referecnce opened a reference window.")
 208
 209
 210 (defvar *ectags-scan-marks* nil
 211   "Holds markers where matches found.")
 212
 213 (defconst ectags-select-non-tag-regexp "\\(\\s-*$\\|In:\\|Finding tag:\\)"
 214   "ectags-select non-tag regex.")
 215
 216
 217 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 218 ;;; Functions
 219
 220 ;; Klaus Berndl <klaus.berndl@sdm.de>: we have to take account that GNU Emacs
 221 ;; > 21.3 has changed its split-string function! For the new split-string is
 222 ;; (cdr (split-string ...)) not nil (at least in our context below), for GNU
 223 ;; Emacs <= 21.3 nil!
 224 (defun ectags-left-trim (str)
 225   "Return a string stripped of all leading whitespaces of STR."
 226   (let ((split-result (split-string str "^[\n\t ]*")))
 227     (or (or (and (cdr split-result) ;; GNU Emacs > 21.3
 228                  (car (cdr split-result)))
 229             (car split-result))
 230         "")))
 231
 232 (defun ectags-right-trim (str)
 233   "Return a string stripped of all trailing whitespaces of STR."
 234   (or (car (split-string str "[\n\t ]*$")) ""))
 235
 236 (defun ectags-trim (str)
 237   "Applies `ectags-right-trim' and `ectags-left-trim' to STR."
 238   (ectags-left-trim (ectags-right-trim str)))
 239
 240 (defun ectags-full-trim (str)
 241   "Applies `ectags-trim' and `ectags-middle-trim' to STR."
 242   (ectags-excessive-trim (ectags-trim str)))
 243
 244 ;; creating tag files  ------------------------------------------------------------------------------------
 245
 246
 247 (defun make-suffix-clauses (languages)
 248   (mapcar (lambda (l)
 249             (mapcar (lambda (s)
 250                       (concat  " -iname \"" s "\""))
 251                     (cdr (assoc-string l ectags-language-file-suffix-alist))))
 252           (split-string languages)))
 253
 254 (defun make-shell-command-prefix (directory)
 255   (concat "find " (expand-file-name directory)))
 256
 257 (defun make-tag-file-name (directory)
 258   (expand-file-name (concat directory (string directory-sep-char) "tags")))
 259
 260 (defun ectag-directory-command (directory languages)
 261   "Produce a command needed to scan the given directory for files
 262    of the given language and produce tags"
 263   (let*
 264       ((suffix-clauses
 265         (car (make-suffix-clauses languages)))
 266        (shell-command-prefix
 267         (make-shell-command-prefix directory))
 268        (shell-command-suffix
 269         (concat " | " ectags-command " -o "  (make-tag-file-name directory) " --options="
 270                 (expand-file-name ectags-config-file) " --verbose --excmd=n --extra=+fq --fields=+afiKlmnsSzt --file-scope=no -L -")))
 271     (concat shell-command-prefix
 272             (car suffix-clauses)
 273             (apply 'concat
 274                    (mapcar (lambda (s)
 275                              (concat " -o" s))
 276                            (cdr suffix-clauses)))
 277             shell-command-suffix)))
 278
 279
 280
 281 ;;;###autoload
 282 (defun ectags-tag-directory ()
 283   "Prompt for a directory and a langage and create a tag file."
 284   (interactive)
 285   ;; prompt for directory
 286   (let ((tag-directory
 287          (read-directory-name "Directory to tag? " default-directory))
 288         (tag-languages (completing-read "Languages to tag? " ectags-language-file-suffix-alist nil nil)))
 289     (add-to-list 'compilation-error-regexp-alist
 290                  '("^\\([^:]+\\) confusing argument declarations beginning at line \\([0-9]+\\))" 1 2))
 291     (compile (ectag-directory-command tag-directory tag-languages) t)))
 292
 293
 294 ;; building tag completion obarray --------------------------------------------------
 295
 296 (defun extract-ectags (&optional tag-buffer obarray)
 297   "Extract a list of tags from a buffer"
 298   (save-excursion
 299     (when tag-buffer
 300       (set-buffer tag-buffer))
 301     (goto-char (point-min))
 302     (forward-line 5)
 303     ;; now point is at first tag
 304     (while (/= (point) (point-max))
 305       (forward-line)
 306       (beginning-of-line)
 307       (let* ((start (point-marker))
 308              (end (progn (forward-word) (point-marker))))
 309         (intern-soft (buffer-substring-no-properties start end) obarray)
 310       (end-of-line))))
 311   obarray)
 312
 313 (defun extract-ectags-files (&optional tag-buffer)
 314   "Extract a list of tags from a tag-buffer"
 315   (let ((result nil))
 316     (save-excursion
 317       (when tag-buffer
 318         (set-buffer tag-buffer))
 319       (goto-char (point-min))
 320       (forward-line 5)
 321       ;; now point is at first tag
 322       (while (search-forward "kind:file" (point-max) t)
 323         (beginning-of-line)
 324         (when (search-forward " " (point-max) t)
 325           (let* ((start
 326                   (point-marker))
 327                  (end (progn
 328                         (search-forward "       " (point-max) t)
 329                         (backward-char)
 330                         (point-marker))))
 331             (add-to-list 'result (buffer-substring-no-properties start end)))
 332           (end-of-line))))
 333       result))
 334
 335
 336 (defun make-ectags-obarray ()
 337   (let ((result (make-vector 65535 0)))
 338     (mapcar (lambda (b)
 339               (when (bufferp b)
 340                 (save-excursion
 341                   (extract-ectags b result))))
 342               (ectags-table-list))
 343     (setq *ectags-obarray* result)))
 344
 345 (defun flatten-file-list (l)
 346   (let (result stack)
 347     (while (or stack l)
 348       (if l
 349           (if (consp l)
 350               (setq stack (cons (cdr l)
 351                                 stack)
 352                     l (car l))
 353             (setq result (cons l result)
 354                   l nil))
 355         (setq l (car stack)
 356               stack (cdr stack))))
 357     result))
 358
 359 (defun make-ectags-file-list ()
 360   "Create a list of all files in the tags"
 361   (let ((result nil))
 362     (setq result
 363            (mapcar (lambda (b) (extract-ectags-files b)) (ectags-table-list)))
 364     (flatten-file-list result)))
 365
 366 ;; tags table mode ------------------------------------------------------------------------------------
 367
 368 (defun ectags-table-list ()
 369   "Return a list of available tag tables."
 370   (let (tags-table-list)
 371     (dolist (buffer (buffer-list) tags-table-list)
 372       (when (assoc 'is-ectag-table (buffer-local-variables buffer))
 373         (push buffer tags-table-list)))
 374     tags-table-list))
 375
 376
 377 (defvar ectags-table-mode-syntax-table
 378   (let ((ectags-syntax-table text-mode-syntax-table))
 379     (modify-syntax-entry ?_ "w" ectags-syntax-table)
 380     (modify-syntax-entry ?- "w" ectags-syntax-table)
 381     (modify-syntax-entry ?# "w" ectags-syntax-table)
 382     (modify-syntax-entry ?! "w" ectags-syntax-table)
 383     (modify-syntax-entry ?\" "w" ectags-syntax-table)
 384     (modify-syntax-entry ?& "w" ectags-syntax-table)
 385     (modify-syntax-entry ?< "w" ectags-syntax-table)
 386     (modify-syntax-entry ?\( "w" ectags-syntax-table)
 387     (modify-syntax-entry ?\) "w" ectags-syntax-table)
 388     (modify-syntax-entry ?: "w" ectags-syntax-table)
 389     (modify-syntax-entry ?\; "w" ectags-syntax-table)
 390     (modify-syntax-entry ?? "w" ectags-syntax-table)
 391     (modify-syntax-entry ?@ "w" ectags-syntax-table)
 392     (modify-syntax-entry ?\ "w" ectags-syntax-table)
 393     (modify-syntax-entry ?\[ "w" ectags-syntax-table)
 394     (modify-syntax-entry ?\] "w" ectags-syntax-table)
 395     (modify-syntax-entry ?\{ "w" ectags-syntax-table)
 396     (modify-syntax-entry ?\} "w" ectags-syntax-table)
 397     (modify-syntax-entry ?| "w" ectags-syntax-table)
 398     (modify-syntax-entry ?\' "w" ectags-syntax-table)
 399     (modify-syntax-entry ?^ "w" ectags-syntax-table)
 400     (modify-syntax-entry ?, "w" ectags-syntax-table)
 401     (modify-syntax-entry ?` "w" ectags-syntax-table)
 402     (modify-syntax-entry ?~ "w" ectags-syntax-table)
 403     ectags-syntax-table)
 404   "Punctuation free table")
 405
 406
 407 ;;;###autoload
 408 (defun ectags-table-mode ()
 409   "Major mode for exuberant ctags table file buffers."
 410   (interactive)
 411   (kill-all-local-variables)
 412   (setq major-mode 'ectags-table-mode)
 413   (set-syntax-table ectags-table-mode-syntax-table)
 414   (setq mode-name "ECTags Tags Table")
 415   (set (make-local-variable 'is-ectag-table) t))
 416
 417
 418
 419 ;; removing tags tables ------------------------------------------------------------------------------------
 420
 421 (defun ectags-wipe-tag-tables ()
 422   "Wipe out all ectags tables"
 423   (interactive)
 424   (mapcar
 425    (lambda (x)
 426      (when (bufferp x) (progn (bury-buffer x) (kill-buffer x))))
 427    (ectags-table-list))
 428   (setq *ectags-obarray* nil))
 429
 430 ;; -- adding tags tables ---------------------------------------------------------------------------------
 431
 432
 433 ;; Expand tags table name FILE into a complete file name.
 434 (defun ectags-expand-table-name (file)
 435   (setq file (expand-file-name file))
 436   (if (file-directory-p file)
 437       (expand-file-name "tags" file)
 438     file))
 439
 440 ;; Return non-nil iff the current buffer is a valid etags TAGS file.
 441 (defun ectags-verify-tags-table ()
 442   "Is current buffer actually an ectags table."
 443   ;; Use eq instead of = in case char-after returns nil.
 444   (goto-char (point-min))
 445   (looking-at "!_TAG_FILE_FORMAT"))
 446
 447 (defun ectags-verify-table (file)
 448   "Given a file, read it in to a buffer and validate it as a tags table."
 449   (save-excursion
 450     (message "Validating tags table %s " file)
 451     (if (get-file-buffer file)
 452         (progn
 453           (set-buffer (get-file-buffer file))
 454           (unless (ectags-verify-tags-table)
 455             (fundamental-mode)))
 456       (when (file-exists-p file)
 457         (progn
 458           (set-buffer (find-file-noselect file))
 459           (when (ectags-verify-tags-table)
 460             (ectags-table-mode)))))
 461     (assoc 'is-ectag-table (buffer-local-variables))))
 462
 463 ;;;###autoload
 464 (defun ectags-visit-tags-table (name)
 465   "Visit an exuberant ctags file and add it to the current list of tags tables."
 466   (interactive
 467    (list (read-file-name "Visit tags table (default tags): "
 468                                      default-directory
 469                                      (expand-file-name "tags"
 470                                                        default-directory)
 471                                      t)))
 472   (let ((curbuf (current-buffer))
 473         (local-tags-filename (ectags-expand-table-name name)))
 474     (if (ectags-verify-table local-tags-filename)
 475         ;; We have a valid tags table.
 476         (progn (message "Valid tags table")
 477                (setq *ectags-obarray* (make-ectags-obarray)))
 478       ;; The buffer was not valid.  Don't use it again.
 479       (progn (error "Not a valid tags table")))))
 480
 481
 482 ;; -- saving and reloading sets of tag tables ------------------------------------------------
 483
 484
 485 (defun ectags-output (tag-buffer)
 486   "Output a line needed to restore this table to the tags buffer list"
 487   (insert "(add-working-ectags-table " (buffer-file-name tag-buffer) ")\n"))
 488
 489 (defun save-working-ectags-tables (fname)
 490   "Save the current working list of ectags tables in a file"
 491   (interactive "fFile to save tags tables in?:")
 492   (save-excursion
 493     (with-temp-buffer
 494       (insert
 495        ";; -*- mode: fundamental; coding: emacs-mule; -*-\n"
 496        ";; Created " (current-time-string) "\n"
 497        ";; Emacs version " emacs-version "\n\n"
 498        (dolist (tagbuff (ectags-table-list))
 499          (ectags-output tagbuff))
 500        "\;;")
 501       (write-region (point min) (point-max) fname nil 'nomessage))))
 502
 503 (defun read-working-ectags-tables (fname)
 504   "Read the current working list of ectags tables in a file"
 505   (interactive "fFile to read tags tables from?:")
 506   (load fname))
 507
 508
 509 ;; actually finding tags and so forth ------------------------------------------------------------------------------------------------
 510
 511 (defun ectags-match-tagname (tag-match)
 512   (nth 1 tag-match))
 513
 514 (defun ectags-match-filename (tag-match)
 515   (nth 2 tag-match))
 516
 517 (defun ectags-match-linenumber (tag-match)
 518   (nth 3 tag-match))
 519
 520 (defun ectags-match-tag-info (tag-match)
 521   (nth 4 tag-match))
 522
 523 (defun ectags-fname (tag-match))
 524
 525
 526 (defun match-ectags (tag fname lnumber info)
 527   "Given a tags match, rank it (via regexp match length) and
 528 plonk it in the match candidates."
 529   (let*
 530       ((saved-fold-search case-fold-search)
 531        (case-fold-search (not *ectags-case-sensitive*))
 532        (match-rank (string-match *ectags-regexp* tag)))
 533     (when match-rank
 534       (let
 535          ((full-match-rank (- (length tag) (length *ectags-regexp*))))
 536 ;;        (message (format "Found %s ranking %d " tag full-match-rank))
 537         (add-to-list '*ectags-matches*
 538                      (list
 539                       full-match-rank
 540                       tag
 541                       fname
 542                       (string-to-number lnumber)
 543                       (ectags-trim info)))))
 544     (setq case-fold-search saved-fold-search)))
 545
 546 (defun scan-ectag (fn tag-buffer)
 547   "Scan a tag table buffer for a match with a tag. Applies fn to all matches."
 548   (save-excursion
 549     (set-buffer tag-buffer)
 550     (goto-char (point-min))
 551     (while (re-search-forward (format "^\\([^   ]*%s[^  ]*\\)   \\([^   ]+\\)   \\([0-9]+\\);\"\\(.+\\)$" *ectags-regexp*)  nil t)
 552       (apply fn (list (match-string-no-properties 1)
 553                       (match-string-no-properties 2)
 554                       (match-string-no-properties 3)
 555                       (match-string-no-properties 4))))))
 556
 557 (defun find-ectag (fn tag-buffer)
 558   "Scan a tag table buffer for an exact match with a tag"
 559   (save-excursion
 560     (set-buffer tag-buffer)
 561     (goto-char (point-min))
 562     (while (re-search-forward (format "^\\(%s\\)        \\([^   ]+\\)   \\([0-9]+\\);\"\\(.+\\)$" *ectags-regexp*)  nil t)
 563       (apply fn (list (match-string-no-properties 1)
 564                       (match-string-no-properties 2)
 565                       (match-string-no-properties 3)
 566                       (match-string-no-properties 4))))))
 567
 568 (defun seek-ectag  (regexp locate-fn)
 569   "Seek a match for the current regexp with the tags in the current tag table buffer"
 570   (setq *ectags-matches* nil)
 571   (setq *ectags-regexp* regexp)
 572   (dolist (tags-buffer (ectags-table-list))
 573     (funcall locate-fn 'match-ectags tags-buffer)
 574     (setq *ectags-matches*
 575           (sort *ectags-matches* '(lambda (x y)
 576                                     (< (car x) (car y)))))))
 577
 578
 579  ;; hiipe expand tag ----------------------------------------------------------
 580 (defun he-ectag-beg ()
 581   (let ((p
 582          (save-excursion
 583            (backward-word 1)
 584            (point))))
 585      p))
 586
 587 ;;;###autoload
 588 (defun try-expand-ectag (old)
 589   (unless  old
 590     (he-init-string (he-tag-beg) (point))
 591     (setq he-expand-list
 592           (sort
 593            (all-completions he-search-string *ectags-obarray*) 'string-lessp))
 594     (while (and he-expand-list
 595                 (he-string-member (car he-expand-list) he-tried-table))
 596       (setq he-expand-list (cdr he-expand-list))))
 597   (if (null he-expand-list)
 598       (progn
 599         (when old (he-reset-string))
 600         ())
 601     (he-substitute-string (car he-expand-list))
 602     (setq he-expand-list (cdr he-expand-list))
 603     t))
 604
 605
 606
 607 ;; ectags search  ---------------------------------------------------------------------------------------------
 608
 609
 610 (defun ectags-file-scan (file-list tag)
 611   "Scan the list of files for the tag and return a list of markers where it is found"
 612   (let ((result)
 613         (found))
 614     (loop
 615      for file in file-list
 616      do (save-excursion
 617           (message "Scanning %s " file)
 618           (find-file file)
 619           (setq found nil)
 620           (while (search-forward tag (point-max) t)
 621             (setq found t)
 622             (message "Found in %s " file)
 623             (add-to-list 'result (list file (line-number-at-pos (point)))))
 624           (kill-buffer nil)))
 625     result))
 626
 627 (defun reference-ectag (tag)
 628   "Scan all currently tagged files for a tag and return a list of markers"
 629   (let*  ((file-list (make-ectags-file-list)))
 630     (setq *ectags-scan-marks* (ectags-file-scan file-list tag))))
 631
 632 (defun next-ectag-reference ()
 633   "Goto next ectag reference in current list, used as with tags-loop-continue"
 634   (interactive)
 635   (if (not (zerop (length *ectags-scan-marks*)))
 636     (let ((mark (car *ectags-scan-marks*)))
 637       (find-file (car mark))
 638       (forward-line (cadr mark))
 639       (setq *ectags-scan-marks* (cdr *ectags-scan-marks*)))
 640     (let ((ref-tag
 641            (or  (find-tag-default)
 642                 (completing-read "Tag to reference " *ectags-obarray*))))
 643       (reference-ectag (tag))
 644       (when (not (zerop (length *ectags-scan-marks*)))
 645         (next-ectag-reference)))))
 646
 647
 648 (defun insert-ectag-references (tagname)
 649   "Insert a refererence to a tag in an ectags-select buffer"
 650   (loop
 651    for index from 0 below (length *ectags-scan-marks*)
 652    do
 653    (let ((mark (nth index *ectags-scan-marks*)))
 654      (insert "<" (int-to-string index) ">:["
 655              tagname " in "
 656              (car mark) "@"
 657              (int-to-string (cadr mark))  "]\n"
 658              "*"  "\n"))))
 659
 660 (defun list-ectag-references (tag)
 661   "List all references to the tag in a suitable buffer"
 662   (setq *ectags-scan-marks* nil)
 663   (setq *ectags-reference-source-buffer* (buffer-name))
 664   (get-buffer-create *ectags-reference-buffer-name*)
 665   (set-buffer *ectags-reference-buffer-name*)
 666   (setq buffer-read-only nil)
 667   (erase-buffer)
 668   (insert "Finding tag: " tagname "\n")
 669   (reference-ectag tag)
 670   (if (not (zerop  (length *ectags-scan-marks*)))
 671       (progn
 672         (insert-ectag-references tag)
 673         (set-buffer *ectags-reference-buffer-name*)
 674         (goto-char (point-min))
 675         (set-buffer-modified-p nil)
 676         (setq buffer-read-only t)
 677         (setq *ectags-reference-opened-window* (selected-window))
 678         (unless (get-buffer-window *ectags-reference-buffer-name*)
 679           (select-window (split-window-vertically))
 680           (switch-to-buffer *ectags-reference-buffer-name*)
 681           (ectags-select-mode))
 682         (shrink-window-if-larger-than-buffer))
 683     (progn
 684       (message "Failed to find any references to tag %s " tagname)
 685       (ding))))
 686
 687
 688 ;; ectags mode ------------------------------------------------------------------------------------------------
 689
 690 (defun ectags-select-case-fold-search ()
 691   (when (boundp 'tags-case-fold-search)
 692     (if (memq tags-case-fold-search '(nil t))
 693         tags-case-fold-search
 694       case-fold-search)))
 695
 696 (defun ectags-select-insert-matches (tagname)
 697   (when *ectags-matches*
 698     (set-buffer *ectags-select-buffer-name*)
 699     (loop for index from 0 below (min (length *ectags-matches*) *ectags-max-candidates*)
 700           do
 701           (let ((mtch (nth index *ectags-matches*)))
 702             (insert "<" (int-to-string index) ">:["
 703                     (ectags-match-tagname mtch) " in "
 704                     (ectags-match-filename mtch) "@"
 705                     (int-to-string (ectags-match-linenumber mtch))  "]\n"
 706                     "*" (ectags-match-tag-info mtch) "\n")))))
 707
 708 (defun ectags-select-find (tagname)
 709   "Actually find a list of tags and push them into the tags select buffer"
 710   (setq *ectags-select-source-buffer* (buffer-name))
 711   (get-buffer-create *ectags-select-buffer-name*)
 712   (set-buffer *ectags-select-buffer-name*)
 713   (setq buffer-read-only nil)
 714   (erase-buffer)
 715   (insert "Finding tag: " tagname "\n")
 716   (seek-ectag tagname 'scan-ectag)
 717   (if (>  (length *ectags-matches*) 0)
 718       (progn  (ectags-select-insert-matches tagname)
 719               (set-buffer *ectags-select-buffer-name*)
 720               (goto-char (point-min))
 721               (ectags-select-next-tag)
 722               (set-buffer-modified-p nil)
 723               (setq buffer-read-only t)
 724               (setq *ectags-select-opened-window* (selected-window))
 725               (unless (get-buffer-window *ectags-select-buffer-name*)
 726                 (select-window (split-window-vertically))
 727                 (switch-to-buffer *ectags-select-buffer-name*)
 728                 (ectags-select-mode))
 729               (shrink-window-if-larger-than-buffer))
 730     (progn
 731       (message "Failed to find tag: %s " tagname)
 732       (ding))))
 733
 734
 735 (defun ectags-select-goto-tag ()
 736   "Goto the tag we currently have the point over in an ectags select mode window"
 737   (interactive)
 738   (let ((case-fold-search (not *ectags-case-sensitive*)))
 739     (save-excursion
 740       (goto-char (point-min))
 741       (re-search-forward "Finding tag: \\(.*\\)$")
 742       (setq tagname (match-string-no-properties 1)))
 743     (beginning-of-line)
 744     (if (not (looking-at "<"))
 745         (message "Please put the cursor on a line with a tag")
 746       (setq tag-point (point))
 747       (setq overlay-arrow-position (point-marker))
 748       (re-search-forward "\\[\\([^ ]+\\) in \\([^@]+\\)@\\([0-9]+\\)")
 749       (let ((tag (match-string-no-properties 1))
 750             (fname (match-string-no-properties 2))
 751             (lnno (match-string-no-properties 3)))
 752         (ring-insert find-tag-marker-ring (point-marker))
 753         (find-file-other-window fname)
 754         (goto-char (point-min))
 755         (forward-line (1- (string-to-int lnno)))))))
 756
 757
 758 (defun ectags-select-next-tag ()
 759   "Move to next tag in buffer."
 760   (interactive)
 761   (beginning-of-line)
 762   (forward-line))
 763
 764
 765 (defun ectags-select-previous-tag ()
 766   "Move to previous tag in buffer."
 767   (interactive)
 768   (beginning-of-line)
 769   (forward-line -1))
 770
 771
 772 (defun ectags-select-quit ()
 773   "Quit ectags-select buffer."
 774   (interactive)
 775   (kill-buffer nil)
 776   (delete-window))
 777
 778 (defun ectags-select-by-tag-number (first-digit)
 779   (let ((tag-num (read-from-minibuffer "Tag number? " first-digit))
 780         (current-point (point)))
 781     (goto-char (point-min))
 782     (if (re-search-forward (concat "^<" tag-num ">") nil t)
 783 ;; TODO -- need to push tag and close window
 784         (ectags-select-goto-tag)
 785       (goto-char current-point)
 786       (message (concat "Couldn't find tag number " tag-num))
 787       (ding))))
 788
 789
 790 ;; user commands ------------------------------------------------------------------------------------------------------
 791
 792 ;;;###autoload
 793 (defun ectags-select-find-tag-at-point ()
 794   "Do a find-tag-at-point, and display all exact matches.  If only one match is
 795 found, see the `etags-select-no-select-for-one-match' variable to decide what
 796 to do."
 797   (interactive)
 798   (let ((tag-to-find
 799          (or (find-tag-default)
 800              (completing-read "Tag to find" *ectags-obarray*))))
 801   (ectags-select-find tag-to-find)))
 802
 803 ;;;###autoload
 804 (defun ectags-select-reference-tag-at-point ()
 805   "Do a search for tag in all files in tags tables and list all hits"
 806   (interactive)
 807   (let ((tag-to-find
 808          (or (find-tag-default)
 809              (completing-read "Tag to find" *ectags-obarray*))))
 810     (list-ectag-references tag-to-find)))
 811
 812
 813 ;;;###autoload
 814 (defun ectags-select-find-tag ()
 815   "Do a find-tag, and display all exact matches.  If only one match is
 816 found, see the `etags-select-no-select-for-one-match' variable to decide what
 817 to do."
 818   (interactive)
 819   (let ((tagname (read-from-minibuffer
 820                   (format "Find tag (default %s): " (find-tag-default)) nil nil
 821                   nil 'find-tag-history)))
 822     (when (string= tagname "")
 823       (setq tagname (find-tag-default)))
 824     (ectags-select-find tagname)))
 825
 826 ;;;###autoload
 827 (defun ectags-select-reference-tag ()
 828   "Do a find-tag, and display all exact matches.  If only one match is
 829 found, see the `etags-select-no-select-for-one-match' variable to decide what
 830 to do."
 831   (interactive)
 832   (let ((tagname (read-from-minibuffer
 833                   (format "Find tag (default %s): " (find-tag-default)) nil nil
 834                   nil 'find-tag-history)))
 835     (when (string= tagname "")
 836       (setq tagname (find-tag-default)))
 837     (list-ectag-references tagname)))
 838
 839 ;; eldoc mode ------------------------------------------------------------------------------------------------
 840
 841
 842 ;;;###autoload
 843 (defun c-eldoc-scope ()
 844   "Try to figure out our scope"
 845   (save-excursion
 846     (c-end-of-defun)
 847     (c-beginning-of-defun-1)
 848     (forward-line -1)
 849     (c-syntactic-re-search-forward "::")
 850     (backward-char 2)
 851     (when (c-on-identifier)
 852       (let* ((id-end (point))
 853              (id-start (progn (backward-char 1) (c-beginning-of-current-token) (point))))
 854             (buffer-substring-no-properties id-start id-end)))))
 855
 856 ;; finds the current function and position in argument list
 857 ;;;###autoload
 858 (defun c-eldoc-function (&optional limit)
 859   (let* ((literal-limits (c-literal-limits))
 860          (literal-type (c-literal-type literal-limits)))
 861     (save-excursion
 862       ;; if this is a string, move out to function domain
 863       (when (eq literal-type 'string)
 864         (goto-char (car literal-limits))
 865         (setq literal-type nil))
 866       (if literal-type
 867           nil
 868         (when (c-on-identifier)
 869           (let* ((id-on (point-marker))
 870                  (id-start
 871                   (progn (c-beginning-of-current-token)
 872                          ;; are we looking at a double colon?
 873                          (if (and (= (char-before)  ?:)
 874                                   (= (char-before (1- (point))) ?:))
 875                              (progn
 876                                (backward-char 3)
 877                                (c-beginning-of-current-token)
 878                                (point-marker))
 879                            (point-marker))))
 880                  (id-end
 881                   (progn
 882                     (goto-char id-on)
 883                     (forward-char)
 884                     (c-end-of-current-token)
 885                     (point-marker))))
 886             (buffer-substring-no-properties id-start id-end)))))))
 887
 888 ;; non scoped verison for more conservative languages
 889 ;;;###autoload
 890 (defun ectags-eldoc-print-current-symbol-info ()
 891   "Print the ectags info associated with the current eldoc symbol"
 892   (let* ((eldoc-sym (c-eldoc-function (- (point) 1000))))
 893     (seek-ectag eldoc-sym 'find-ectag)
 894     (if (> (length *ectags-matches*) 0)
 895         (ectags-match-tag-info (car *ectags-matches*))
 896       (format "Unknown %s " eldoc-sym))))
 897
 898 ;; scoped version for cpp and the like : tries to find symbol in current scope first
 899 ;; scope format is a format string that concatenates the cureend scope and the symbol with the scope operator
 900 ;; eg "%s::%s" for c++
 901 ;;;###autoload
 902 (defun ectags-eldoc-print-current-scoped-symbol-info ()
 903   "Try to find the meaning of the symbol in the current scope. Probably only useful for cpp mode"
 904   (let* ((eldoc-scope (c-eldoc-scope))
 905          (eldoc-sym (c-eldoc-function (- (point) 1000))))
 906     (when eldoc-sym
 907       (seek-ectag (format "%s::%s" eldoc-scope eldoc-sym) 'find-ectag)
 908       (if (> (length *ectags-matches*) 0)
 909           (format "%s::%s %s" eldoc-scope eldoc-sym (ectags-match-tag-info (car *ectags-matches*)))
 910         (progn
 911           (seek-ectag eldoc-sym 'find-ectag)
 912           (if (> (length *ectags-matches*) 0)
 913               (format "%s %s" eldoc-sym (ectags-match-tag-info (car *ectags-matches*)))
 914             (if eldoc-scope
 915                 (format "Scope %s " eldoc-scope))
 916             (format "Unknown %s " eldoc-sym)))))))
 917
 918 ;;;###autoload
 919 (defun ectags-turn-on-eldoc-mode (&optional scope-format)
 920   (interactive)
 921   (if scope-format
 922       (set (make-local-variable 'eldoc-documentation-function)
 923            'ectags-eldoc-print-current-scoped-symbol-info)
 924       (set (make-local-variable 'eldoc-documentation-function)
 925            'ectags-eldoc-print-current-symbol-info)
 926   (turn-on-eldoc-mode)))
 927
 928
 929 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 930 ;;; Keymap
 931
 932
 933 (defvar ectags-select-mode-map nil "'ectags-select-mode' keymap.")
 934 (if (not ectags-select-mode-map)
 935     (let ((map (make-keymap)))
 936       (define-key map [(return)] 'ectags-select-goto-tag)
 937       (define-key map [(down)] 'ectags-select-next-tag)
 938       (define-key map [(up)] 'ectags-select-previous-tag)
 939       (define-key map [(q)] 'ectags-select-quit)
 940       (define-key map "0" (lambda () (interactive) (ectags-select-by-tag-number "0")))
 941       (define-key map "1" (lambda () (interactive) (ectags-select-by-tag-number "1")))
 942       (define-key map "2" (lambda () (interactive) (ectags-select-by-tag-number "2")))
 943       (define-key map "3" (lambda () (interactive) (ectags-select-by-tag-number "3")))
 944       (define-key map "4" (lambda () (interactive) (ectags-select-by-tag-number "4")))
 945       (define-key map "5" (lambda () (interactive) (ectags-select-by-tag-number "5")))
 946       (define-key map "6" (lambda () (interactive) (ectags-select-by-tag-number "6")))
 947       (define-key map "7" (lambda () (interactive) (ectags-select-by-tag-number "7")))
 948       (define-key map "8" (lambda () (interactive) (ectags-select-by-tag-number "8")))
 949       (define-key map "9" (lambda () (interactive) (ectags-select-by-tag-number "9")))
 950       (setq ectags-select-mode-map map)))
 951
 952
 953
 954
 955
 956 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 957 ;;; Mode startup
 958 (defun ectags-select-mode ()
 959   "ectags-select-mode is a mode for browsing through exuberant ctags.\n\n
 960 \\{ectags-select-mode-map}"
 961   (interactive)
 962   (kill-all-local-variables)
 963   (setq major-mode 'ectags-select-mode)
 964   (setq mode-name "Ectags Select")
 965   (set-syntax-table text-mode-syntax-table)
 966   (use-local-map ectags-select-mode-map)
 967   (make-local-variable 'font-lock-defaults)
 968   (setq ectags-select-mode-font-lock-keywords
 969         (list
 970          (list "^<\\([0-9]+\\)>:\\[\\([^ ]+\\) in \\([^@]+\\)@\\([0-9]+)\\)\\]"
 971                '(1 font-lock-warning-face) '(2 font-lock-function-name-face) '(3 font-lock-keyword-face) '(4 font-lock-warning-face))))
 972   (setq font-lock-defaults '(ectags-select-mode-font-lock-keywords))
 973   (setq overlay-arrow-position nil)
 974   (run-hooks 'ectags-select-mode-hook))
 975
 976
 977 (provide 'ectags)
 978
 979