From: Chong Yidong Date: Sat, 29 Aug 2009 19:32:33 +0000 (+0000) Subject: cedet/semantic/adebug.el, cedet/semantic/chart.el, X-Git-Tag: emacs-pretest-23.1.90~1091^2~100 X-Git-Url: http://git.eshelyaron.com/gitweb/?a=commitdiff_plain;h=f273dfc6ffeef2b3e3cbd1779cd3a6089858622c;p=emacs.git cedet/semantic/adebug.el, cedet/semantic/chart.el, cedet/semantic/db-debug.el, cedet/semantic/db-ebrowse.el, cedet/semantic/db-el.el, cedet/semantic/db-file.el, cedet/semantic/db-javascript.el, cedet/semantic/db-search.el, cedet/semantic/db-typecache.el, cedet/semantic/dep.el, cedet/semantic/ia.el, cedet/semantic/tag-file.el, cedet/semantic/tag-ls.el: New files. --- diff --git a/lisp/cedet/semantic/adebug.el b/lisp/cedet/semantic/adebug.el new file mode 100644 index 00000000000..fe8e71b82e8 --- /dev/null +++ b/lisp/cedet/semantic/adebug.el @@ -0,0 +1,423 @@ +;;; adebug.el --- Semantic Application Debugger + +;;; Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc. + +;; Author: Eric M. Ludlam + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; Semantic datastructure debugger for semantic applications. +;; Uses data-debug for core implementation. +;; +;; Goals: +;; +;; Inspect all known details of a TAG in a buffer. +;; +;; Analyze the list of active semantic databases, and the tags therin. +;; +;; Allow interactive navigation of the analysis process, tags, etc. + +(require 'data-debug) +(require 'eieio-datadebug) +(require 'semantic/analyze) + +;;; Code: + +;;; SEMANTIC TAG STUFF +;; +(defun data-debug-insert-tag-parts (tag prefix &optional parent) + "Insert all the parts of TAG. +PREFIX specifies what to insert at the start of each line. +PARENT specifires any parent tag." + (data-debug-insert-thing (semantic-tag-name tag) + prefix + "Name: " + parent) + (insert prefix "Class: '" (format "%S" (semantic-tag-class tag)) "\n") + (when (semantic-tag-with-position-p tag) + (let ((ol (semantic-tag-overlay tag)) + (file (semantic-tag-file-name tag)) + (start (semantic-tag-start tag)) + (end (semantic-tag-end tag)) + ) + (insert prefix "Position: " + (if (and (numberp start) (numberp end)) + (format "%d -> %d in " start end) + "") + (if file (file-name-nondirectory file) "unknown-file") + (if (semantic-overlay-p ol) + " " + "") + "\n") + (data-debug-insert-thing ol prefix + "Position Data: " + parent) + )) + (let ((attrprefix (concat (make-string (length prefix) ? ) "# "))) + (insert prefix "Attributes:\n") + (data-debug-insert-property-list + (semantic-tag-attributes tag) attrprefix tag) + (insert prefix "Properties:\n") + (data-debug-insert-property-list + (semantic-tag-properties tag) attrprefix tag) + ) + + ) + +(defun data-debug-insert-tag-parts-from-point (point) + "Call `data-debug-insert-tag-parts' based on text properties at POINT." + (let ((tag (get-text-property point 'ddebug)) + (parent (get-text-property point 'ddebug-parent)) + (indent (get-text-property point 'ddebug-indent)) + start + ) + (end-of-line) + (setq start (point)) + (forward-char 1) + (data-debug-insert-tag-parts tag + (concat (make-string indent ? ) + "| ") + parent) + (goto-char start) + )) + +(defun data-debug-insert-tag (tag prefix prebuttontext &optional parent) + "Insert TAG into the current buffer at the current point. +PREFIX specifies text to insert in front of TAG. +PREBUTTONTEXT is text appearing btewen the prefix and TAG. +Optional PARENT is the parent tag containing TAG. +Add text properties needed to allow tag expansion later." + (let ((start (point)) + (end nil) + (str (semantic-format-tag-uml-abbreviate tag parent t)) + (tip (semantic-format-tag-prototype tag parent t)) + ) + (insert prefix prebuttontext str "\n") + (setq end (point)) + (put-text-property start end 'ddebug tag) + (put-text-property start end 'ddebug-parent parent) + (put-text-property start end 'ddebug-indent(length prefix)) + (put-text-property start end 'ddebug-prefix prefix) + (put-text-property start end 'help-echo tip) + (put-text-property start end 'ddebug-function + 'data-debug-insert-tag-parts-from-point) + + )) + +;;; TAG LISTS +;; +(defun data-debug-insert-tag-list (taglist prefix &optional parent) + "Insert the tag list TAGLIST with PREFIX. +Optional argument PARENT specifies the part of TAGLIST." + (condition-case nil + (while taglist + (cond ((and (consp taglist) (semantic-tag-p (car taglist))) + (data-debug-insert-tag (car taglist) prefix "" parent)) + ((consp taglist) + (data-debug-insert-thing (car taglist) prefix "" parent)) + (t (data-debug-insert-thing taglist prefix "" parent))) + (setq taglist (cdr taglist))) + (error nil))) + +(defun data-debug-insert-taglist-from-point (point) + "Insert the taglist found at the taglist button at POINT." + (let ((taglist (get-text-property point 'ddebug)) + (parent (get-text-property point 'ddebug-parent)) + (indent (get-text-property point 'ddebug-indent)) + start + ) + (end-of-line) + (setq start (point)) + (forward-char 1) + (data-debug-insert-tag-list taglist + (concat (make-string indent ? ) + "* ") + parent) + (goto-char start) + + )) + +(defun data-debug-insert-tag-list-button (taglist prefix prebuttontext &optional parent) + "Insert a single summary of a TAGLIST. +PREFIX is the text that preceeds the button. +PREBUTTONTEXT is some text between PREFIX and the taglist button. +PARENT is the tag that represents the parent of all the tags." + (let ((start (point)) + (end nil) + (str (format "#" (safe-length taglist))) + (tip nil)) + (insert prefix prebuttontext str) + (setq end (point)) + (put-text-property (- end (length str)) end 'face 'font-lock-function-name-face) + (put-text-property start end 'ddebug taglist) + (put-text-property start end 'ddebug-parent parent) + (put-text-property start end 'ddebug-indent(length prefix)) + (put-text-property start end 'ddebug-prefix prefix) + (put-text-property start end 'help-echo tip) + (put-text-property start end 'ddebug-function + 'data-debug-insert-taglist-from-point) + (insert "\n") + )) + +;;; SEMANTICDB FIND RESULTS +;; +(defun data-debug-insert-find-results (findres prefix) + "Insert the find results FINDRES with PREFIX." + ;; ( (DBOBJ TAG TAG TAG) (DBOBJ TAG TAG TAG) ... ) + (let ((cnt 1)) + (while findres + (let* ((dbhit (car findres)) + (db (car dbhit)) + (tags (cdr dbhit))) + (data-debug-insert-thing db prefix (format "DB %d: " cnt)) + (data-debug-insert-thing tags prefix (format "HITS %d: " cnt)) + ) + (setq findres (cdr findres) + cnt (1+ cnt))))) + +(defun data-debug-insert-find-results-from-point (point) + "Insert the find results found at the find results button at POINT." + (let ((findres (get-text-property point 'ddebug)) + (indent (get-text-property point 'ddebug-indent)) + start + ) + (end-of-line) + (setq start (point)) + (forward-char 1) + (data-debug-insert-find-results findres + (concat (make-string indent ? ) + "!* ") + ) + (goto-char start) + )) + +(defun data-debug-insert-find-results-button (findres prefix prebuttontext) + "Insert a single summary of a find results FINDRES. +PREFIX is the text that preceeds the button. +PREBUTTONTEXT is some text between prefix and the find results button." + (let ((start (point)) + (end nil) + (str (semanticdb-find-result-prin1-to-string findres)) + (tip nil)) + (insert prefix prebuttontext str) + (setq end (point)) + (put-text-property (- end (length str)) end 'face 'font-lock-function-name-face) + (put-text-property start end 'ddebug findres) + (put-text-property start end 'ddebug-indent(length prefix)) + (put-text-property start end 'ddebug-prefix prefix) + (put-text-property start end 'help-echo tip) + (put-text-property start end 'ddebug-function + 'data-debug-insert-find-results-from-point) + (insert "\n") + )) + +(defun data-debug-insert-db-and-tag-button (dbtag prefix prebuttontext) + "Insert a single summary of short list DBTAG of format (DB . TAG). +PREFIX is the text that preceeds the button. +PREBUTTONTEXT is some text between prefix and the find results button." + (let ((start (point)) + (end nil) + (str (concat "(# + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; A set of simple functions for charting details about a file based on +;; the output of the semantic parser. +;; + +(require 'semantic) +(require 'chart) + +;;; Code: + +(defun semantic-chart-tags-by-class (&optional tagtable) + "Create a bar chart representing the number of tags for a given tag class. +Each bar represents how many toplevel tags in TAGTABLE +exist with a given class. See `semantic-symbol->name-assoc-list' +for tokens which will be charted. +TAGTABLE is passedto `semantic-something-to-tag-table'." + (interactive) + (let* ((stream (semantic-something-to-tag-table + (or tagtable (current-buffer)))) + (names (mapcar 'cdr semantic-symbol->name-assoc-list)) + (nums (mapcar + (lambda (symname) + (length + (semantic-brute-find-tag-by-class (car symname) + stream) + )) + semantic-symbol->name-assoc-list))) + (chart-bar-quickie 'vertical + "Semantic Toplevel Tag Volume" + names "Tag Class" + nums "Volume") + )) + +(defun semantic-chart-database-size (&optional tagtable) + "Create a bar chart representing the size of each file in semanticdb. +Each bar represents how many toplevel tags in TAGTABLE +exist in each database entry. +TAGTABLE is passed to `semantic-something-to-tag-table'." + (interactive) + (if (or (not (fboundp 'semanticdb-minor-mode-p)) + (not (semanticdb-minor-mode-p))) + (error "Semanticdb is not enabled")) + (let* ((db semanticdb-current-database) + (dbt (semanticdb-get-database-tables db)) + (names (mapcar 'car + (object-assoc-list + 'file + dbt))) + (numnuts (mapcar (lambda (dba) + (prog1 + (cons + (if (slot-boundp dba 'tags) + (length (oref dba tags)) + 1) + (car names)) + (setq names (cdr names)))) + dbt)) + (nums nil) + (fh (/ (- (frame-height) 7) 4))) + (setq numnuts (sort numnuts (lambda (a b) (> (car a) (car b))))) + (setq names (mapcar 'cdr numnuts) + nums (mapcar 'car numnuts)) + (if (> (length names) fh) + (progn + (setcdr (nthcdr fh names) nil) + (setcdr (nthcdr fh nums) nil))) + (chart-bar-quickie 'horizontal + "Semantic DB Toplevel Tag Volume" + names "File" + nums "Volume") + )) + +(defun semantic-chart-token-complexity (tok) + "Calculate the `complexity' of token TOK." + (count-lines + (semantic-tag-end tok) + (semantic-tag-start tok))) + +(defun semantic-chart-tag-complexity + (&optional class tagtable) + "Create a bar chart representing the complexity of some tags. +Complexity is calculated for tags of CLASS. Each bar represents +the complexity of some tag in TAGTABLE. Only the most complex +items are charted. TAGTABLE is passedto +`semantic-something-to-tag-table'." + (interactive) + (let* ((sym (if (not class) 'function)) + (stream + (semantic-find-tags-by-class + sym (semantic-something-to-tag-table (or tagtable + (current-buffer))) + )) + (name (cond ((semantic-tag-with-position-p (car stream)) + (buffer-name (semantic-tag-buffer (car stream)))) + (t ""))) + (cplx (mapcar (lambda (tok) + (cons tok (semantic-chart-token-complexity tok))) + stream)) + (namelabel (cdr (assoc 'function semantic-symbol->name-assoc-list))) + (names nil) + (nums nil)) + (setq cplx (sort cplx (lambda (a b) (> (cdr a) (cdr b))))) + (while (and cplx (<= (length names) (/ (- (frame-height) 7) 4))) + (setq names (cons (semantic-tag-name (car (car cplx))) + names) + nums (cons (cdr (car cplx)) nums) + cplx (cdr cplx))) +;; ;; (setq names (mapcar (lambda (str) +;; ;; (substring str (- (length str) 10))) +;; ;; names)) + (chart-bar-quickie 'horizontal + (format "%s Complexity in %s" + (capitalize (symbol-name sym)) + name) + names namelabel + nums "Complexity (Lines of code)") + )) + +(defun semantic-chart-analyzer () + "Chart the extent of the context analysis." + (interactive) + (let* ((p (semanticdb-find-translate-path nil nil)) + (plen (length p)) + (tab semanticdb-current-table) + (tc (semanticdb-get-typecache tab)) + (tclen (+ (length (oref tc filestream)) + (length (oref tc includestream)))) + (scope (semantic-calculate-scope)) + (fslen (length (oref scope fullscope))) + (lvarlen (length (oref scope localvar))) + ) + (chart-bar-quickie 'vertical + (format "Analyzer Overhead in %s" (buffer-name)) + '("includes" "typecache" "scopelen" "localvar") + "Overhead Entries" + (list plen tclen fslen lvarlen) + "Number of tags") + )) + + + +(provide 'semantic/chart) + +;;; semantic-chart.el ends here diff --git a/lisp/cedet/semantic/db-debug.el b/lisp/cedet/semantic/db-debug.el new file mode 100644 index 00000000000..6db1cbfaae9 --- /dev/null +++ b/lisp/cedet/semantic/db-debug.el @@ -0,0 +1,108 @@ +;;; db-debug.el --- Extra level debugging routines for Semantic + +;;; Copyright (C) 2008, 2009 Free Software Foundation, Inc. + +;; Author: Eric M. Ludlam + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; Various routines for debugging SemanticDB issues, or viewing +;; semanticdb state. + +(require 'semantic/db) + +;;; Code: +;; +(defun semanticdb-dump-all-table-summary () + "Dump a list of all databases in Emacs memory." + (interactive) + (require 'data-debug) + (let ((db semanticdb-database-list)) + (data-debug-new-buffer "*SEMANTICDB*") + (data-debug-insert-stuff-list db "*"))) + +(defalias 'semanticdb-adebug-database-list 'semanticdb-dump-all-table-summary) + +(defun semanticdb-adebug-current-database () + "Run ADEBUG on the current database." + (interactive) + (require 'data-debug) + (let ((p semanticdb-current-database) + ) + (data-debug-new-buffer "*SEMANTICDB ADEBUG*") + (data-debug-insert-stuff-list p "*"))) + +(defun semanticdb-adebug-current-table () + "Run ADEBUG on the current database." + (interactive) + (require 'data-debug) + (let ((p semanticdb-current-table)) + (data-debug-new-buffer "*SEMANTICDB ADEBUG*") + (data-debug-insert-stuff-list p "*"))) + + +(defun semanticdb-adebug-project-database-list () + "Run ADEBUG on the current database." + (interactive) + (require 'data-debug) + (let ((p (semanticdb-current-database-list))) + (data-debug-new-buffer "*SEMANTICDB ADEBUG*") + (data-debug-insert-stuff-list p "*"))) + + + +;;; Sanity Checks +;; + +(defun semanticdb-table-oob-sanity-check (cache) + "Validate that CACHE tags do not have any overlays in them." + (while cache + (when (semantic-overlay-p (semantic-tag-overlay cache)) + (message "Tag %s has an erroneous overlay!" + (semantic-format-tag-summarize (car cache)))) + (semanticdb-table-oob-sanity-check + (semantic-tag-components-with-overlays (car cache))) + (setq cache (cdr cache)))) + +(defun semanticdb-table-sanity-check (&optional table) + "Validate the current semanticdb TABLE." + (interactive) + (if (not table) (setq table semanticdb-current-table)) + (let* ((full-filename (semanticdb-full-filename table)) + (buff (find-buffer-visiting full-filename))) + (if buff + (save-excursion + (set-buffer buff) + (semantic-sanity-check)) + ;; We can't use the usual semantic validity check, so hack our own. + (semanticdb-table-oob-sanity-check (semanticdb-get-tags table))))) + +(defun semanticdb-database-sanity-check () + "Validate the current semantic database." + (interactive) + (let ((tables (semanticdb-get-database-tables + semanticdb-current-database))) + (while tables + (semanticdb-table-sanity-check (car tables)) + (setq tables (cdr tables))) + )) + + + +(provide 'semantic/db-debug) +;;; semanticdb-debug.el ends here diff --git a/lisp/cedet/semantic/db-ebrowse.el b/lisp/cedet/semantic/db-ebrowse.el new file mode 100644 index 00000000000..3302afd83da --- /dev/null +++ b/lisp/cedet/semantic/db-ebrowse.el @@ -0,0 +1,706 @@ +;;; db-ebrowse.el --- Semanticdb backend using ebrowse. + +;;; Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. + +;; Authors: Eric M. Ludlam , Joakim Verona +;; Keywords: tags + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; This program was started by Eric Ludlam, and Joakim Verona finished +;; the implementation by adding searches and fixing bugs. +;; +;; Read in custom-created ebrowse BROWSE files into a semanticdb back +;; end. +;; +;; Add these databases to the 'system' search. +;; Possibly use ebrowse for local parsing too. +;; +;; When real details are needed out of the tag system from ebrowse, +;; we will need to delve into the originating source and parse those +;; files the usual way. +;; +;; COMMANDS: +;; `semanticdb-create-ebrowse-database' - Call EBROWSE to create a +;; system database for some directory. In general, use this for +;; system libraries, such as /usr/include, or include directories +;; large software projects. +;; Customize `semanticdb-ebrowse-file-match' to make sure the correct +;; file extensions are matched. +;; +;; `semanticdb-load-ebrowse-caches' - Load all the EBROWSE caches from +;; your semanticdb system database directory. Once they are +;; loaded, they become searchable as omnipotent databases for +;; all C++ files. This is called automatically by semantic-load. +;; Call it a second time to refresh the Emacs DB with the file. +;; + +(eval-when-compile + ;; For generic function searching. + (require 'eieio) + (require 'eieio-opt) + ) +(require 'semantic/db-file) + +(eval-and-compile + ;; Hopefully, this will allow semanticdb-ebrowse to compile under + ;; XEmacs, it just won't run if a user attempts to use it. + (condition-case nil + (require 'ebrowse) + (error nil))) + +;;; Code: +(defvar semanticdb-ebrowse-default-file-name "BROWSE" + "The EBROWSE file name used for system caches.") + +(defcustom semanticdb-ebrowse-file-match "\\.\\(hh?\\|HH?\\|hpp\\)" + "Regular expression matching file names for ebrowse to parse. +This expression should exclude C++ headers that have no extension. +By default, include only headers since the semantic use of EBrowse +is only for searching via semanticdb, and thus only headers would +be searched." + :group 'semanticdb + :type 'string) + +(defun semanticdb-ebrowse-C-file-p (file) + "Is FILE a C or C++ file?" + (or (string-match semanticdb-ebrowse-file-match file) + (and (string-match "/\\w+$" file) + (not (file-directory-p file)) + (let ((tmp (get-buffer-create "*semanticdb-ebrowse-tmp*"))) + (save-excursion + (set-buffer tmp) + (condition-case nil + (insert-file-contents file nil 0 100 t) + (error (insert-file-contents file nil nil nil t))) + (goto-char (point-min)) + (looking-at "\\s-*/\\(\\*\\|/\\)") + )) + ))) + +(defun semanticdb-create-ebrowse-database (dir) + "Create an EBROSE database for directory DIR. +The database file is stored in ~/.semanticdb, or whichever directory +is specified by `semanticdb-default-save-directory'." + (interactive "DDirectory: ") + (setq dir (file-name-as-directory dir)) ;; for / on end + (let* ((savein (semanticdb-ebrowse-file-for-directory dir)) + (filebuff (get-buffer-create "*SEMANTICDB EBROWSE TMP*")) + (files (directory-files (expand-file-name dir) t)) + (mma auto-mode-alist) + (regexp nil) + ) + ;; Create the input to the ebrowse command + (save-excursion + (set-buffer filebuff) + (buffer-disable-undo filebuff) + (setq default-directory (expand-file-name dir)) + + ;;; @TODO - convert to use semanticdb-collect-matching-filenames + ;; to get the file names. + + + (mapcar (lambda (f) + (when (semanticdb-ebrowse-C-file-p f) + (insert f) + (insert "\n"))) + files) + ;; Cleanup the ebrowse output buffer. + (save-excursion + (set-buffer (get-buffer-create "*EBROWSE OUTPUT*")) + (erase-buffer)) + ;; Call the EBROWSE command. + (message "Creating ebrowse file: %s ..." savein) + (call-process-region (point-min) (point-max) + "ebrowse" nil "*EBROWSE OUTPUT*" nil + (concat "--output-file=" savein) + "--very-verbose") + ) + ;; Create a short LOADER program for loading in this database. + (let* ((lfn (concat savein "-load.el")) + (lf (find-file-noselect lfn))) + (save-excursion + (set-buffer lf) + (erase-buffer) + (insert "(semanticdb-ebrowse-load-helper \"" + (expand-file-name dir) + "\")\n") + (save-buffer) + (kill-buffer (current-buffer))) + (message "Creating ebrowse file: %s ... done" savein) + ;; Reload that database + (load lfn nil t) + ))) + +(defun semanticdb-load-ebrowse-caches () + "Load all semanticdb controlled EBROWSE caches." + (interactive) + (let ((f (directory-files semanticdb-default-save-directory + t (concat semanticdb-ebrowse-default-file-name "-load.el$") t))) + (while f + (load (car f) nil t) + (setq f (cdr f))) + )) + +(defun semanticdb-ebrowse-load-helper (directory) + "Create the semanticdb database via ebrowse for directory. +If DIRECTORY is found to be defunct, it won't load the DB, and will +warn instead." + (if (file-directory-p directory) + (semanticdb-create-database semanticdb-project-database-ebrowse + directory) + (let* ((BF (semanticdb-ebrowse-file-for-directory directory)) + (BFL (concat BF "-load.el")) + (BFLB (concat BF "-load.el~"))) + (save-window-excursion + (with-output-to-temp-buffer "*FILES TO DELETE*" + (princ "The following BROWSE files are obsolete.\n\n") + (princ BF) + (princ "\n") + (princ BFL) + (princ "\n") + (when (file-exists-p BFLB) + (princ BFLB) + (princ "\n")) + ) + (when (y-or-n-p (format + "Warning: Obsolete BROWSE file for: %s\nDelete? " + directory)) + (delete-file BF) + (delete-file BFL) + (when (file-exists-p BFLB) + (delete-file BFLB)) + ))))) + +;;; SEMANTIC Database related Code +;;; Classes: +(defclass semanticdb-table-ebrowse (semanticdb-table) + ((major-mode :initform c++-mode) + (ebrowse-tree :initform nil + :initarg :ebrowse-tree + :documentation + "The raw ebrowse tree for this file." + ) + (global-extract :initform nil + :initarg :global-extract + :documentation + "Table of ebrowse tags specific to this file. +This table is compisited from the ebrowse *Globals* section.") + ) + "A table for returning search results from ebrowse.") + +(defclass semanticdb-project-database-ebrowse + (semanticdb-project-database) + ((new-table-class :initform semanticdb-table-ebrowse + :type class + :documentation + "New tables created for this database are of this class.") + (system-include-p :initform nil + :initarg :system-include + :documentation + "Flag indicating this database represents a system include directory.") + (ebrowse-struct :initform nil + :initarg :ebrowse-struct + ) + ) + "Semantic Database deriving tags using the EBROWSE tool. +EBROWSE is a C/C++ parser for use with `ebrowse' Emacs program.") + +;JAVE this just instantiates a default empty ebrowse struct? +; how would new instances wind up here? +; the ebrowse class isnt singleton, unlike the emacs lisp one +(defvar-mode-local c++-mode semanticdb-project-system-databases + () + "Search Ebrowse for symbols.") + +(defmethod semanticdb-needs-refresh-p ((table semanticdb-table-ebrowse)) + "EBROWSE database do not need to be refreshed. + +JAVE: stub for needs-refresh, because, how do we know if BROWSE files + are out of date? + +EML: Our database should probably remember the timestamp/checksum of + the most recently read EBROWSE file, and use that." + nil +) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + + +;;; EBROWSE code +;; +;; These routines deal with part of the ebrowse interface. +(defun semanticdb-ebrowse-file-for-directory (dir) + "Return the file name for DIR where the ebrowse BROWSE file is. +This file should reside in `semanticdb-default-save-directory'." + (let* ((semanticdb-default-save-directory + semanticdb-default-save-directory) + (B (semanticdb-file-name-directory + 'semanticdb-project-database-file + (concat (expand-file-name dir) + semanticdb-ebrowse-default-file-name))) + ) + B)) + +(defun semanticdb-ebrowse-get-ebrowse-structure (dir) + "Return the ebrowse structure for directory DIR. +This assumes semantic manages the BROWSE files, so they are assumed to live +where semantic cache files live, depending on your settings. + +For instance: /home//.semanticdb/!usr!include!BROWSE" + (let* ((B (semanticdb-ebrowse-file-for-directory dir)) + (buf (get-buffer-create "*semanticdb ebrowse*"))) + (message "semanticdb-ebrowse %s" B) + (when (file-exists-p B) + (set-buffer buf) + (buffer-disable-undo buf) + (erase-buffer) + (insert-file-contents B) + (let ((ans nil) + (efcn (symbol-function 'ebrowse-show-progress))) + (fset 'ebrowse-show-progress #'(lambda (&rest junk) nil)) + (unwind-protect ;; Protect against errors w/ ebrowse + (setq ans (list B (ebrowse-read))) + ;; These items must always happen + (erase-buffer) + (fset 'ebrowse-show-fcn efcn) + ) + ans)))) + +;;; Methods for creating a database or tables +;; +(defmethod semanticdb-create-database :STATIC ((dbeC semanticdb-project-database-ebrowse) + directory) + "Create a new semantic database for DIRECTORY based on ebrowse. +If there is no database for DIRECTORY available, then +{not implemented yet} create one. Return nil if that is not possible." + ;; MAKE SURE THAT THE FILE LOADED DOESN'T ALREADY EXIST. + (let ((dbs semanticdb-database-list) + (found nil)) + (while (and (not found) dbs) + (when (semanticdb-project-database-ebrowse-p (car dbs)) + (when (string= (oref (car dbs) reference-directory) directory) + (setq found (car dbs)))) + (setq dbs (cdr dbs))) + ;;STATIC means DBE cant be used as object, only as a class + (let* ((ebrowse-data (semanticdb-ebrowse-get-ebrowse-structure directory)) + (dat (car (cdr ebrowse-data))) + (ebd (car dat)) + (db nil) + (default-directory directory) + ) + (if found + (setq db found) + (setq db (make-instance + dbeC + directory + :ebrowse-struct ebd + )) + (oset db reference-directory directory)) + + ;; Once we recycle or make a new DB, refresh the + ;; contents from the BROWSE file. + (oset db tables nil) + ;; only possible after object creation, tables inited to nil. + (semanticdb-ebrowse-strip-trees db dat) + + ;; Once our database is loaded, if we are a system DB, we + ;; add ourselves to the include list for C++. + (semantic-add-system-include directory 'c++-mode) + (semantic-add-system-include directory 'c-mode) + + db))) + +(defmethod semanticdb-ebrowse-strip-trees ((dbe semanticdb-project-database-ebrowse) + data) + "For the ebrowse database DBE, strip all tables from DATA." +;JAVE what it actually seems to do is split the original tree in "tables" associated with files +; im not sure it actually works: +; the filename slot sometimes gets to be nil, +; apparently for classes which definition cant be found, yet needs to be included in the tree +; like library baseclasses +; a file can define several classes + (let ((T (car (cdr data))));1st comes a header, then the tree + (while T + + (let* ((tree (car T)) + (class (ebrowse-ts-class tree)); root class of tree + ;; Something funny going on with this file thing... + (filename (or (ebrowse-cs-source-file class) + (ebrowse-cs-file class))) + ) + (cond + ((ebrowse-globals-tree-p tree) + ;; We have the globals tree.. save this special. + (semanticdb-ebrowse-add-globals-to-table dbe tree) + ) + (t + ;; ebrowse will collect all the info from multiple files + ;; into one tree. Semantic wants all the bits to be tied + ;; into different files. We need to do a full dissociation + ;; into semantic parsable tables. + (semanticdb-ebrowse-add-tree-to-table dbe tree) + )) + (setq T (cdr T)))) + )) + +;;; Filename based methods +;; +(defun semanticdb-ebrowse-add-globals-to-table (dbe tree) + "For database DBE, add the ebrowse TREE into the table." + (if (or (not (ebrowse-ts-p tree)) + (not (ebrowse-globals-tree-p tree))) + (signal 'wrong-type-argument (list 'ebrowse-ts-p tree))) + + (let* ((class (ebrowse-ts-class tree)) + (fname (or (ebrowse-cs-source-file class) + (ebrowse-cs-file class) + ;; Not def'd here, assume our current + ;; file + (concat default-directory "/unknown-proxy.hh"))) + (vars (ebrowse-ts-member-functions tree)) + (fns (ebrowse-ts-member-variables tree)) + (toks nil) + ) + (while vars + (let ((nt (semantic-tag (ebrowse-ms-name (car vars)) + 'variable)) + (defpoint (ebrowse-bs-point class))) + (when defpoint + (semantic--tag-set-overlay nt + (vector defpoint defpoint))) + (setq toks (cons nt toks))) + (setq vars (cdr vars))) + (while fns + (let ((nt (semantic-tag (ebrowse-ms-name (car fns)) + 'function)) + (defpoint (ebrowse-bs-point class))) + (when defpoint + (semantic--tag-set-overlay nt + (vector defpoint defpoint))) + (setq toks (cons nt toks))) + (setq fns (cdr fns))) + + )) + +(defun semanticdb-ebrowse-add-tree-to-table (dbe tree &optional fname baseclasses) + "For database DBE, add the ebrowse TREE into the table for FNAME. +Optional argument BASECLASSES specifyies a baseclass to the tree being provided." + (if (not (ebrowse-ts-p tree)) + (signal 'wrong-type-argument (list 'ebrowse-ts-p tree))) + + ;; Strategy overview: + ;; 1) Calculate the filename for this tree. + ;; 2) Find a matching namespace in TAB, or create a new one. + ;; 3) Fabricate a tag proxy for CLASS + ;; 4) Add it to the namespace + ;; 5) Add subclasses + + ;; 1 - Find the filename + (if (not fname) + (setq fname (or (ebrowse-cs-source-file (ebrowse-ts-class tree)) + (ebrowse-cs-file (ebrowse-ts-class tree)) + ;; Not def'd here, assume our current + ;; file + (concat default-directory "/unknown-proxy.hh")))) + + (let* ((tab (or (semanticdb-file-table dbe fname) + (semanticdb-create-table dbe fname))) + (class (ebrowse-ts-class tree)) + (scope (ebrowse-cs-scope class)) + (ns (when scope (cedet-split-string scope ":" t))) + (nst nil) + (cls nil) + ) + + ;; 2 - Get the namespace tag + (when ns + (let ((taglst (if (slot-boundp tab 'tags) (oref tab tags) nil))) + (setq nst (semantic-find-first-tag-by-name (car ns) taglst)) + (when (not nst) + (setq nst (semantic-tag (car ns) 'type :type "namespace")) + (oset tab tags (cons nst taglst)) + ))) + + ;; 3 - Create a proxy tg. + (setq cls (semantic-tag (ebrowse-cs-name class) + 'type + :type "class" + :superclasses baseclasses + :faux t + :filename fname + )) + (let ((defpoint (ebrowse-bs-point class))) + (when defpoint + (semantic--tag-set-overlay cls + (vector defpoint defpoint)))) + + ;; 4 - add to namespace + (if nst + (semantic-tag-put-attribute + nst :members (cons cls (semantic-tag-get-attribute nst :members))) + (oset tab tags (cons cls (when (slot-boundp tab 'tags) + (oref tab tags))))) + + ;; 5 - Subclasses + (let* ((subclass (ebrowse-ts-subclasses tree)) + (pname (ebrowse-cs-name class))) + (when (ebrowse-cs-scope class) + (setq pname (concat (mapconcat (lambda (a) a) (cdr ns) "::") "::" pname))) + + (while subclass + (let* ((scc (ebrowse-ts-class (car subclass))) + (fname (or (ebrowse-cs-source-file scc) + (ebrowse-cs-file scc) + ;; Not def'd here, assume our current + ;; file + fname + ))) + (when fname + (semanticdb-ebrowse-add-tree-to-table + dbe (car subclass) fname pname))) + (setq subclass (cdr subclass)))) + )) + +;;; +;; Overload for converting the simple faux tag into something better. +;; +(defmethod semanticdb-normalize-tags ((obj semanticdb-table-ebrowse) tags) + "Convert in Ebrowse database OBJ a list of TAGS into a complete tag. +The default tag provided by searches exclude many features of a +semantic parsed tag. Look up the file for OBJ, and match TAGS +against a semantic parsed tag that has all the info needed, and +return that." + (let ((tagret nil) + ) + ;; SemanticDB will automatically create a regular database + ;; on top of the file just loaded by ebrowse during the set + ;; buffer. Fetch that table, and use it's tag list to look + ;; up the tag we just got, and thus turn it into a full semantic + ;; tag. + (while tags + (let ((tag (car tags))) + (save-excursion + (semanticdb-set-buffer obj) + (let ((ans nil)) + ;; Gee, it would be nice to do this, but ebrowse LIES. Oi. + (when (semantic-tag-with-position-p tag) + (goto-char (semantic-tag-start tag)) + (let ((foundtag (semantic-current-tag))) + ;; Make sure the discovered tag is the same as what we started with. + (when (string= (semantic-tag-name tag) + (semantic-tag-name foundtag)) + ;; We have a winner! + (setq ans foundtag)))) + ;; Sometimes ebrowse lies. Do a generic search + ;; to find it within this file. + (when (not ans) + ;; We might find multiple hits for this tag, and we have no way + ;; of knowing which one the user wanted. Return the first one. + (setq ans (semantic-deep-find-tags-by-name + (semantic-tag-name tag) + (semantic-fetch-tags)))) + (if (semantic-tag-p ans) + (setq tagret (cons ans tagret)) + (setq tagret (append ans tagret))) + )) + (setq tags (cdr tags)))) + tagret)) + +(defmethod semanticdb-normalize-one-tag ((obj semanticdb-table-ebrowse) tag) + "Convert in Ebrowse database OBJ one TAG into a complete tag. +The default tag provided by searches exclude many features of a +semantic parsed tag. Look up the file for OBJ, and match TAG +against a semantic parsed tag that has all the info needed, and +return that." + (let ((tagret nil) + (objret nil)) + ;; SemanticDB will automatically create a regular database + ;; on top of the file just loaded by ebrowse during the set + ;; buffer. Fetch that table, and use it's tag list to look + ;; up the tag we just got, and thus turn it into a full semantic + ;; tag. + (save-excursion + (semanticdb-set-buffer obj) + (setq objret semanticdb-current-table) + (when (not objret) + ;; What to do?? + (debug)) + (let ((ans nil)) + ;; Gee, it would be nice to do this, but ebrowse LIES. Oi. + (when (semantic-tag-with-position-p tag) + (goto-char (semantic-tag-start tag)) + (let ((foundtag (semantic-current-tag))) + ;; Make sure the discovered tag is the same as what we started with. + (when (string= (semantic-tag-name tag) + (semantic-tag-name foundtag)) + ;; We have a winner! + (setq ans foundtag)))) + ;; Sometimes ebrowse lies. Do a generic search + ;; to find it within this file. + (when (not ans) + ;; We might find multiple hits for this tag, and we have no way + ;; of knowing which one the user wanted. Return the first one. + (setq ans (semantic-deep-find-tags-by-name + (semantic-tag-name tag) + (semantic-fetch-tags)))) + (if (semantic-tag-p ans) + (setq tagret ans) + (setq tagret (car ans))) + )) + (cons objret tagret))) + +;;; Search Overrides +;; +;; NOTE WHEN IMPLEMENTING: Be sure to add doc-string updates explaining +;; how your new search routines are implemented. +;; +(defmethod semanticdb-find-tags-by-name-method + ((table semanticdb-table-ebrowse) name &optional tags) + "Find all tags named NAME in TABLE. +Return a list of tags." + ;;(message "semanticdb-find-tags-by-name-method name -- %s" name) + (if tags + ;; If TAGS are passed in, then we don't need to do work here. + (call-next-method) + ;; If we ever need to do something special, add here. + ;; Since ebrowse tags are converted into semantic tags, we can + ;; get away with this sort of thing. + (call-next-method) + ) + ) + +(defmethod semanticdb-find-tags-by-name-regexp-method + ((table semanticdb-table-ebrowse) regex &optional tags) + "Find all tags with name matching REGEX in TABLE. +Optional argument TAGS is a list of tags to search. +Return a list of tags." + (if tags (call-next-method) + ;; YOUR IMPLEMENTATION HERE + (call-next-method) + )) + +(defmethod semanticdb-find-tags-for-completion-method + ((table semanticdb-table-ebrowse) prefix &optional tags) + "In TABLE, find all occurances of tags matching PREFIX. +Optional argument TAGS is a list of tags to search. +Returns a table of all matching tags." + (if tags (call-next-method) + ;; YOUR IMPLEMENTATION HERE + (call-next-method) + )) + +(defmethod semanticdb-find-tags-by-class-method + ((table semanticdb-table-ebrowse) class &optional tags) + "In TABLE, find all occurances of tags of CLASS. +Optional argument TAGS is a list of tags to search. +Returns a table of all matching tags." + (if tags (call-next-method) + (call-next-method))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Deep Searches +;; +;; If your language does not have a `deep' concept, these can be left +;; alone, otherwise replace with implementations similar to those +;; above. +;; + +(defmethod semanticdb-deep-find-tags-by-name-method + ((table semanticdb-table-ebrowse) name &optional tags) + "Find all tags name NAME in TABLE. +Optional argument TAGS is a list of tags t +Like `semanticdb-find-tags-by-name-method' for ebrowse." + ;;(semanticdb-find-tags-by-name-method table name tags) + (call-next-method)) + +(defmethod semanticdb-deep-find-tags-by-name-regexp-method + ((table semanticdb-table-ebrowse) regex &optional tags) + "Find all tags with name matching REGEX in TABLE. +Optional argument TAGS is a list of tags to search. +Like `semanticdb-find-tags-by-name-method' for ebrowse." + ;;(semanticdb-find-tags-by-name-regexp-method table regex tags) + (call-next-method)) + +(defmethod semanticdb-deep-find-tags-for-completion-method + ((table semanticdb-table-ebrowse) prefix &optional tags) + "In TABLE, find all occurances of tags matching PREFIX. +Optional argument TAGS is a list of tags to search. +Like `semanticdb-find-tags-for-completion-method' for ebrowse." + ;;(semanticdb-find-tags-for-completion-method table prefix tags) + (call-next-method)) + +;;; Advanced Searches +;; +(defmethod semanticdb-find-tags-external-children-of-type-method + ((table semanticdb-table-ebrowse) type &optional tags) + "Find all nonterminals which are child elements of TYPE +Optional argument TAGS is a list of tags to search. +Return a list of tags." + (if tags (call-next-method) + ;; Ebrowse collects all this type of stuff together for us. + ;; but we can't use it.... yet. + nil + )) + +;;; TESTING +;; +;; This is a complex bit of stuff. Here are some tests for the +;; system. + +(defun semanticdb-ebrowse-run-tests () + "Run some tests of the semanticdb-ebrowse system. +All systems are different. Ask questions along the way." + (interactive) + (let ((doload nil)) + (when (y-or-n-p "Create a system database to test with? ") + (call-interactively 'semanticdb-create-ebrowse-database) + (setq doload t)) + ;; Should we load in caches + (when (if doload + (y-or-n-p "New database created. Reload system databases? ") + (y-or-n-p "Load in all system databases? ")) + (semanticdb-load-ebrowse-caches))) + ;; Ok, databases were creatd. Lets try some searching. + (when (not (or (eq major-mode 'c-mode) + (eq major-mode 'c++-mode))) + (error "Please make your default buffer be a C or C++ file, then +run the test again..") + ) + + ) + +(defun semanticdb-ebrowse-dump () + "Find the first loaded ebrowse table, and dump out the contents." + (interactive) + (let ((db semanticdb-database-list) + (ab nil)) + (while db + (when (semanticdb-project-database-ebrowse-p (car db)) + (setq ab (data-debug-new-buffer "*EBROWSE Database*")) + (data-debug-insert-thing (car db) "*" "") + (setq db nil) + ) + (setq db (cdr db))))) + +(provide 'semantic/db-ebrowse) + +;;; semanticdb-ebrowse.el ends here diff --git a/lisp/cedet/semantic/db-el.el b/lisp/cedet/semantic/db-el.el new file mode 100644 index 00000000000..3db6c15570e --- /dev/null +++ b/lisp/cedet/semantic/db-el.el @@ -0,0 +1,343 @@ +;;; db-el.el --- Semantic database extensions for Emacs Lisp + +;;; Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 +;;; Free Software Foundation, Inc. + +;; Author: Eric M. Ludlam +;; Keywords: tags + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; There are a lot of Emacs Lisp functions and variables available for +;; the asking. This adds on to the semanticdb programming interface to +;; allow all loaded Emacs Lisp functions to be queried via semanticdb. +;; +;; This allows you to use programs written for Semantic using the database +;; to also work in Emacs Lisp with no compromises. +;; + +(require 'semantic/db-search) +(eval-when-compile + ;; For generic function searching. + (require 'eieio) + (require 'eieio-opt) + (require 'eieio-base) + ) +;;; Code: + +;;; Classes: +(defclass semanticdb-table-emacs-lisp (semanticdb-abstract-table) + ((major-mode :initform emacs-lisp-mode) + ) + "A table for returning search results from Emacs.") + +(defmethod semanticdb-refresh-table ((obj semanticdb-table-emacs-lisp) &optional force) + "Do not refresh Emacs Lisp table. +It does not need refreshing." + nil) + +(defmethod semanticdb-needs-refresh-p ((obj semanticdb-table-emacs-lisp)) + "Return nil, we never need a refresh." + nil) + +(defclass semanticdb-project-database-emacs-lisp + (semanticdb-project-database eieio-singleton) + ((new-table-class :initform semanticdb-table-emacs-lisp + :type class + :documentation + "New tables created for this database are of this class.") + ) + "Database representing Emacs core.") + +;; Create the database, and add it to searchable databases for Emacs Lisp mode. +(defvar-mode-local emacs-lisp-mode semanticdb-project-system-databases + (list + (semanticdb-project-database-emacs-lisp "Emacs")) + "Search Emacs core for symbols.") + +(defvar-mode-local emacs-lisp-mode semanticdb-find-default-throttle + '(project omniscience) + "Search project files, then search this omniscience database. +It is not necessary to to system or recursive searching because of +the omniscience database.") + +;;; Filename based methods +;; +(defmethod semanticdb-get-database-tables ((obj semanticdb-project-database-emacs-lisp)) + "For an Emacs Lisp database, there are no explicit tables. +Create one of our special tables that can act as an intermediary." + ;; We need to return something since there is always the "master table" + ;; The table can then answer file name type questions. + (when (not (slot-boundp obj 'tables)) + (let ((newtable (semanticdb-table-emacs-lisp "Emacs System Table"))) + (oset obj tables (list newtable)) + (oset newtable parent-db obj) + (oset newtable tags nil) + )) + (call-next-method)) + +(defmethod semanticdb-file-table ((obj semanticdb-project-database-emacs-lisp) filename) + "From OBJ, return FILENAME's associated table object. +For Emacs Lisp, creates a specialized table." + (car (semanticdb-get-database-tables obj)) + ) + +(defmethod semanticdb-get-tags ((table semanticdb-table-emacs-lisp )) + "Return the list of tags belonging to TABLE." + ;; specialty table ? Probably derive tags at request time. + nil) + +(defmethod semanticdb-equivalent-mode ((table semanticdb-table-emacs-lisp) &optional buffer) + "Return non-nil if TABLE's mode is equivalent to BUFFER. +Equivalent modes are specified by by `semantic-equivalent-major-modes' +local variable." + (save-excursion + (set-buffer buffer) + (eq (or mode-local-active-mode major-mode) 'emacs-lisp-mode))) + +(defmethod semanticdb-full-filename ((obj semanticdb-table-emacs-lisp)) + "Fetch the full filename that OBJ refers to. +For Emacs Lisp system DB, there isn't one." + nil) + +;;; Conversion +;; +(defmethod semanticdb-normalize-tags ((obj semanticdb-table-emacs-lisp) tags) + "Convert tags, originating from Emacs OBJ, into standardized form." + (let ((newtags nil)) + (dolist (T tags) + (let* ((ot (semanticdb-normalize-one-tag obj T)) + (tag (cdr ot))) + (setq newtags (cons tag newtags)))) + ;; There is no promise to have files associated. + (nreverse newtags))) + +(defmethod semanticdb-normalize-one-tag ((obj semanticdb-table-emacs-lisp) tag) + "Convert one TAG, originating from Emacs OBJ, into standardized form. +If Emacs cannot resolve this symbol to a particular file, then return nil." + ;; Here's the idea. For each tag, get the name, then use + ;; Emacs' `symbol-file' to get the source. Once we have that, + ;; we can use more typical semantic searching techniques to + ;; get a regularly parsed tag. + (let* ((type (cond ((semantic-tag-of-class-p tag 'function) + 'defun) + ((semantic-tag-of-class-p tag 'variable) + 'defvar) + )) + (sym (intern (semantic-tag-name tag))) + (file (condition-case err + (symbol-file sym type) + ;; Older [X]Emacs don't have a 2nd argument. + (error (symbol-file sym)))) + ) + (if (or (not file) (not (file-exists-p file))) + ;; The file didn't exist. Return nil. + ;; We can't normalize this tag. Fake it out. + (cons obj tag) + (when (string-match "\\.elc" file) + (setq file (concat (file-name-sans-extension file) + ".el")) + (when (and (not (file-exists-p file)) + (file-exists-p (concat file ".gz"))) + ;; Is it a .gz file? + (setq file (concat file ".gz")))) + + (let* ((tab (semanticdb-file-table-object file)) + (alltags (semanticdb-get-tags tab)) + (newtags (semanticdb-find-tags-by-name-method + tab (semantic-tag-name tag))) + (match nil)) + ;; Find the best match. + (dolist (T newtags) + (when (semantic-tag-similar-p T tag) + (setq match T))) + ;; Backup system. + (when (not match) + (setq match (car newtags))) + ;; Return it. + (cons tab match))))) + +(defun semanticdb-elisp-sym-function-arglist (sym) + "Get the argument list for SYM. +Deal with all different forms of function. +This was snarfed out of eldoc." + (let* ((prelim-def + (let ((sd (and (fboundp sym) + (symbol-function sym)))) + (and (symbolp sd) + (condition-case err + (setq sd (indirect-function sym)) + (error (setq sd nil)))) + sd)) + (def (if (eq (car-safe prelim-def) 'macro) + (cdr prelim-def) + prelim-def)) + (arglist (cond ((null def) nil) + ((byte-code-function-p def) + ;; This is an eieio compatibility function. + ;; We depend on EIEIO, so use this. + (eieio-compiled-function-arglist def)) + ((eq (car-safe def) 'lambda) + (nth 1 def)) + (t nil)))) + arglist)) + +(defun semanticdb-elisp-sym->tag (sym &optional toktype) + "Convert SYM into a semantic tag. +TOKTYPE is a hint to the type of tag desired." + (if (stringp sym) + (setq sym (intern-soft sym))) + (when sym + (cond ((and (eq toktype 'function) (fboundp sym)) + (semantic-tag-new-function + (symbol-name sym) + nil ;; return type + (semantic-elisp-desymbolify + (semanticdb-elisp-sym-function-arglist sym)) ;; arg-list + :user-visible-flag (condition-case nil + (interactive-form sym) + (error nil)) + )) + ((and (eq toktype 'variable) (boundp sym)) + (semantic-tag-new-variable + (symbol-name sym) + nil ;; type + nil ;; value - ignore for now + )) + ((and (eq toktype 'type) (class-p sym)) + (semantic-tag-new-type + (symbol-name sym) + "class" + (semantic-elisp-desymbolify + (aref (class-v semanticdb-project-database) + class-public-a)) ;; slots + (semantic-elisp-desymbolify (class-parents sym)) ;; parents + )) + ((not toktype) + ;; Figure it out on our own. + (cond ((class-p sym) + (semanticdb-elisp-sym->tag sym 'type)) + ((fboundp sym) + (semanticdb-elisp-sym->tag sym 'function)) + ((boundp sym) + (semanticdb-elisp-sym->tag sym 'variable)) + (t nil)) + ) + (t nil)))) + +;;; Search Overrides +;; +(defvar semanticdb-elisp-mapatom-collector nil + "Variable used to collect mapatoms output.") + +(defmethod semanticdb-find-tags-by-name-method + ((table semanticdb-table-emacs-lisp) name &optional tags) + "Find all tags name NAME in TABLE. +Uses `inter-soft' to match NAME to emacs symbols. +Return a list of tags." + (if tags (call-next-method) + ;; No need to search. Use `intern-soft' which does the same thing for us. + (let* ((sym (intern-soft name)) + (fun (semanticdb-elisp-sym->tag sym 'function)) + (var (semanticdb-elisp-sym->tag sym 'variable)) + (typ (semanticdb-elisp-sym->tag sym 'type)) + (taglst nil) + ) + (when (or fun var typ) + ;; If the symbol is any of these things, build the search table. + (when var (setq taglst (cons var taglst))) + (when typ (setq taglst (cons typ taglst))) + (when fun (setq taglst (cons fun taglst))) + taglst + )))) + +(defmethod semanticdb-find-tags-by-name-regexp-method + ((table semanticdb-table-emacs-lisp) regex &optional tags) + "Find all tags with name matching REGEX in TABLE. +Optional argument TAGS is a list of tags to search. +Uses `apropos-internal' to find matches. +Return a list of tags." + (if tags (call-next-method) + (delq nil (mapcar 'semanticdb-elisp-sym->tag + (apropos-internal regex))))) + +(defmethod semanticdb-find-tags-for-completion-method + ((table semanticdb-table-emacs-lisp) prefix &optional tags) + "In TABLE, find all occurances of tags matching PREFIX. +Optional argument TAGS is a list of tags to search. +Returns a table of all matching tags." + (if tags (call-next-method) + (delq nil (mapcar 'semanticdb-elisp-sym->tag + (all-completions prefix obarray))))) + +(defmethod semanticdb-find-tags-by-class-method + ((table semanticdb-table-emacs-lisp) class &optional tags) + "In TABLE, find all occurances of tags of CLASS. +Optional argument TAGS is a list of tags to search. +Returns a table of all matching tags." + (if tags (call-next-method) + ;; We could implement this, but it could be messy. + nil)) + +;;; Deep Searches +;; +;; For Emacs Lisp deep searches are like top level searches. +(defmethod semanticdb-deep-find-tags-by-name-method + ((table semanticdb-table-emacs-lisp) name &optional tags) + "Find all tags name NAME in TABLE. +Optional argument TAGS is a list of tags to search. +Like `semanticdb-find-tags-by-name-method' for Emacs Lisp." + (semanticdb-find-tags-by-name-method table name tags)) + +(defmethod semanticdb-deep-find-tags-by-name-regexp-method + ((table semanticdb-table-emacs-lisp) regex &optional tags) + "Find all tags with name matching REGEX in TABLE. +Optional argument TAGS is a list of tags to search. +Like `semanticdb-find-tags-by-name-method' for Emacs Lisp." + (semanticdb-find-tags-by-name-regexp-method table regex tags)) + +(defmethod semanticdb-deep-find-tags-for-completion-method + ((table semanticdb-table-emacs-lisp) prefix &optional tags) + "In TABLE, find all occurances of tags matching PREFIX. +Optional argument TAGS is a list of tags to search. +Like `semanticdb-find-tags-for-completion-method' for Emacs Lisp." + (semanticdb-find-tags-for-completion-method table prefix tags)) + +;;; Advanced Searches +;; +(defmethod semanticdb-find-tags-external-children-of-type-method + ((table semanticdb-table-emacs-lisp) type &optional tags) + "Find all nonterminals which are child elements of TYPE +Optional argument TAGS is a list of tags to search. +Return a list of tags." + (if tags (call-next-method) + ;; EIEIO is the only time this matters + (when (featurep 'eieio) + (let* ((class (intern-soft type)) + (taglst (when class + (delq nil + (mapcar 'semanticdb-elisp-sym->tag + ;; Fancy eieio function that knows all about + ;; built in methods belonging to CLASS. + (eieio-all-generic-functions class))))) + ) + taglst)))) + +(provide 'semantic/db-el) + +;;; semanticdb-el.el ends here diff --git a/lisp/cedet/semantic/db-file.el b/lisp/cedet/semantic/db-file.el new file mode 100644 index 00000000000..a16f9bbf14a --- /dev/null +++ b/lisp/cedet/semantic/db-file.el @@ -0,0 +1,438 @@ +;;; db-file.el --- Save a semanticdb to a cache file. + +;;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009 +;;; Free Software Foundation, Inc. + +;; Author: Eric M. Ludlam +;; Keywords: tags + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; A set of semanticdb classes for persistently saving caches on disk. +;; + +(require 'semantic) +(require 'semantic/db) +(require 'cedet-files) + +(defvar semanticdb-file-version semantic-version + "Version of semanticdb we are writing files to disk with.") +(defvar semanticdb-file-incompatible-version "1.4" + "Version of semanticdb we are not reverse compatible with.") + +;;; Settings +;; +(defcustom semanticdb-default-file-name "semantic.cache" + "*File name of the semantic tag cache." + :group 'semanticdb + :type 'string) + +(defcustom semanticdb-default-save-directory (expand-file-name "~/.semanticdb") + "*Directory name where semantic cache files are stored. +If this value is nil, files are saved in the current directory. If the value +is a valid directory, then it overrides `semanticdb-default-file-name' and +stores caches in a coded file name in this directory." + :group 'semanticdb + :type '(choice :tag "Default-Directory" + :menu-tag "Default-Directory" + (const :tag "Use current directory" :value nil) + (directory))) + +(defcustom semanticdb-persistent-path '(always) + "*List of valid paths that semanticdb will cache tags to. +When `global-semanticdb-minor-mode' is active, tag lists will +be saved to disk when Emacs exits. Not all directories will have +tags that should be saved. +The value should be a list of valid paths. A path can be a string, +indicating a directory in which to save a variable. An element in the +list can also be a symbol. Valid symbols are `never', which will +disable any saving anywhere, `always', which enables saving +everywhere, or `project', which enables saving in any directory that +passes a list of predicates in `semanticdb-project-predicate-functions'." + :group 'semanticdb + :type nil) + +(defcustom semanticdb-save-database-hooks nil + "*Hooks run after a database is saved. +Each function is called with one argument, the object representing +the database recently written." + :group 'semanticdb + :type 'hook) + +(defvar semanticdb-dir-sep-char (if (boundp 'directory-sep-char) + (symbol-value 'directory-sep-char) + ?/) + "Character used for directory separation. +Obsoleted in some versions of Emacs. Needed in others. +NOTE: This should get deleted from semantic soon.") + +(defun semanticdb-fix-pathname (dir) + "If DIR is broken, fix it. +Force DIR to end with a /. +Note: Same as `file-name-as-directory'. +NOTE: This should get deleted from semantic soon." + (file-name-as-directory dir)) +;; I didn't initially know about the above fcn. Keep the below as a +;; reference. Delete it someday once I've proven everything is the same. +;; (if (not (= semanticdb-dir-sep-char (aref path (1- (length path))))) +;; (concat path (list semanticdb-dir-sep-char)) +;; path)) + +;;; Classes +;; +(defclass semanticdb-project-database-file (semanticdb-project-database + eieio-persistent) + ((file-header-line :initform ";; SEMANTICDB Tags save file") + (do-backups :initform nil) + (semantic-tag-version :initarg :semantic-tag-version + :initform "1.4" + :documentation + "The version of the tags saved. +The default value is 1.4. In semantic 1.4 there was no versioning, so +when those files are loaded, this becomes the version number. +To save the version number, we must hand-set this version string.") + (semanticdb-version :initarg :semanticdb-version + :initform "1.4" + :documentation + "The version of the object system saved. +The default value is 1.4. In semantic 1.4, there was no versioning, +so when those files are loaded, this becomes the version number. +To save the version number, we must hand-set this version string.") + ) + "Database of file tables saved to disk.") + +;;; Code: +;; +(defmethod semanticdb-create-database :STATIC ((dbc semanticdb-project-database-file) + directory) + "Create a new semantic database for DIRECTORY and return it. +If a database for DIRECTORY has already been loaded, return it. +If a database for DIRECTORY exists, then load that database, and return it. +If DIRECTORY doesn't exist, create a new one." + ;; Make sure this is fully expanded so we don't get duplicates. + (setq directory (file-truename directory)) + (let* ((fn (semanticdb-cache-filename dbc directory)) + (db (or (semanticdb-file-loaded-p fn) + (if (file-exists-p fn) + (progn + (semanticdb-load-database fn)))))) + (unless db + (setq db (make-instance + dbc ; Create the database requested. Perhaps + (concat (file-name-nondirectory + (directory-file-name + directory)) + "/") + :file fn :tables nil + :semantic-tag-version semantic-version + :semanticdb-version semanticdb-file-version))) + ;; Set this up here. We can't put it in the constructor because it + ;; would be saved, and we want DB files to be portable. + (oset db reference-directory directory) + db)) + +;;; File IO +(defun semanticdb-load-database (filename) + "Load the database FILENAME." + (require 'inversion) + (condition-case foo + (let* ((r (eieio-persistent-read filename)) + (c (semanticdb-get-database-tables r)) + (tv (oref r semantic-tag-version)) + (fv (oref r semanticdb-version)) + ) + ;; Restore the parent-db connection + (while c + (oset (car c) parent-db r) + (setq c (cdr c))) + (if (not (inversion-test 'semanticdb-file fv)) + (when (inversion-test 'semantic-tag tv) + ;; Incompatible version. Flush tables. + (semanticdb-flush-database-tables r) + ;; Reset the version to new version. + (oset r semantic-tag-version semantic-tag-version) + ;; Warn user + (message "Semanticdb file is old. Starting over for %s" + filename) + ) + ;; Version is not ok. Flush whole system + (message "semanticdb file is old. Starting over for %s" + filename) + ;; This database is so old, we need to replace it. + ;; We also need to delete it from the instance tracker. + (delete-instance r) + (setq r nil)) + r) + (error (message "Cache Error: [%s] %s, Restart" + filename foo) + nil))) + +(defun semanticdb-file-loaded-p (filename) + "Return the project belonging to FILENAME if it was already loaded." + (eieio-instance-tracker-find filename 'file 'semanticdb-database-list)) + +(defmethod semanticdb-file-directory-exists-p ((DB semanticdb-project-database-file) + &optional supress-questions) + "Does the directory the database DB needs to write to exist? +If SUPRESS-QUESTIONS, then do not ask to create the directory." + (let ((dest (file-name-directory (oref DB file))) + ) + (cond ((null dest) + ;; @TODO - If it was never set up... what should we do ? + nil) + ((file-exists-p dest) t) + (supress-questions nil) + ((y-or-n-p (format "Create directory %s for SemanticDB? " + dest)) + (make-directory dest t) + t) + (t nil)) + )) + +(defmethod semanticdb-save-db ((DB semanticdb-project-database-file) + &optional + supress-questions) + "Write out the database DB to its file. +If DB is not specified, then use the current database." + (let ((objname (oref DB file))) + (when (and (semanticdb-dirty-p DB) + (semanticdb-live-p DB) + (semanticdb-file-directory-exists-p DB supress-questions) + (semanticdb-write-directory-p DB) + ) + ;;(message "Saving tag summary for %s..." objname) + (condition-case foo + (eieio-persistent-save (or DB semanticdb-current-database)) + (file-error ; System error saving? Ignore it. + (message "%S: %s" foo objname)) + (error + (cond + ((and (listp foo) + (stringp (nth 1 foo)) + (string-match "write[- ]protected" (nth 1 foo))) + (message (nth 1 foo))) + ((and (listp foo) + (stringp (nth 1 foo)) + (string-match "no such directory" (nth 1 foo))) + (message (nth 1 foo))) + (t + ;; @todo - It should ask if we are not called from a hook. + ;; How? + (if (or supress-questions + (y-or-n-p (format "Skip Error: %S ?" (car (cdr foo))))) + (message "Save Error: %S: %s" (car (cdr foo)) + objname) + (error "%S" (car (cdr foo)))))))) + (run-hook-with-args 'semanticdb-save-database-hooks + (or DB semanticdb-current-database)) + ;;(message "Saving tag summary for %s...done" objname) + ) + )) + +(defmethod semanticdb-live-p ((obj semanticdb-project-database)) + "Return non-nil if the file associated with OBJ is live. +Live databases are objects associated with existing directories." + (and (slot-boundp obj 'reference-directory) + (file-exists-p (oref obj reference-directory)))) + +(defmethod semanticdb-live-p ((obj semanticdb-table)) + "Return non-nil if the file associated with OBJ is live. +Live files are either buffers in Emacs, or files existing on the filesystem." + (let ((full-filename (semanticdb-full-filename obj))) + (or (find-buffer-visiting full-filename) + (file-exists-p full-filename)))) + +(defvar semanticdb-data-debug-on-write-error nil + "Run the data debugger on tables that issue errors. +This variable is set to nil after the first error is encountered +to prevent overload.") + +(defmethod object-write ((obj semanticdb-table)) + "When writing a table, we have to make sure we deoverlay it first. +Restore the overlays after writting. +Argument OBJ is the object to write." + (when (semanticdb-live-p obj) + (when (semanticdb-in-buffer-p obj) + (save-excursion + (set-buffer (semanticdb-in-buffer-p obj)) + + ;; Make sure all our tag lists are up to date. + (semantic-fetch-tags) + + ;; Try to get an accurate unmatched syntax table. + (when (and (boundp semantic-show-unmatched-syntax-mode) + semantic-show-unmatched-syntax-mode) + ;; Only do this if the user runs unmatched syntax + ;; mode display enties. + (oset obj unmatched-syntax + (semantic-show-unmatched-lex-tokens-fetch)) + ) + + ;; Make sure pointmax is up to date + (oset obj pointmax (point-max)) + )) + + ;; Make sure that the file size and other attributes are + ;; up to date. + (let ((fattr (file-attributes (semanticdb-full-filename obj)))) + (oset obj fsize (nth 7 fattr)) + (oset obj lastmodtime (nth 5 fattr)) + ) + + ;; Do it! + (condition-case tableerror + (call-next-method) + (error + (when semanticdb-data-debug-on-write-error + (require 'data-debug) + (data-debug-new-buffer (concat "*SEMANTICDB ERROR*")) + (data-debug-insert-thing obj "*" "") + (setq semanticdb-data-debug-on-write-error nil)) + (message "Error Writing Table: %s" (object-name obj)) + (error "%S" (car (cdr tableerror))))) + + ;; Clear the dirty bit. + (oset obj dirty nil) + )) + +;;; State queries +;; +(defmethod semanticdb-write-directory-p ((obj semanticdb-project-database-file)) + "Return non-nil if OBJ should be written to disk. +Uses `semanticdb-persistent-path' to determine the return value." + (let ((path semanticdb-persistent-path)) + (catch 'found + (while path + (cond ((stringp (car path)) + (if (string= (oref obj reference-directory) (car path)) + (throw 'found t))) + ((eq (car path) 'project) + ;; @TODO - EDE causes us to go in here and disable + ;; the old default 'always save' setting. + ;; + ;; With new default 'always' should I care? + (if semanticdb-project-predicate-functions + (if (run-hook-with-args-until-success + 'semanticdb-project-predicate-functions + (oref obj reference-directory)) + (throw 'found t)) + ;; If the mode is 'project, and there are no project + ;; modes, then just always save the file. If users + ;; wish to restrict the search, modify + ;; `semanticdb-persistent-path' to include desired paths. + (if (= (length semanticdb-persistent-path) 1) + (throw 'found t)) + )) + ((eq (car path) 'never) + (throw 'found nil)) + ((eq (car path) 'always) + (throw 'found t)) + (t (error "Invalid path %S" (car path)))) + (setq path (cdr path))) + (call-next-method)) + )) + +;;; Filename manipulation +;; +(defmethod semanticdb-file-table ((obj semanticdb-project-database-file) filename) + "From OBJ, return FILENAME's associated table object." + ;; Cheater option. In this case, we always have files directly + ;; under ourselves. The main project type may not. + (object-assoc (file-name-nondirectory filename) 'file (oref obj tables))) + +(defmethod semanticdb-file-name-non-directory :STATIC + ((dbclass semanticdb-project-database-file)) + "Return the file name DBCLASS will use. +File name excludes any directory part." + semanticdb-default-file-name) + +(defmethod semanticdb-file-name-directory :STATIC + ((dbclass semanticdb-project-database-file) directory) + "Return the relative directory to where DBCLASS will save its cache file. +The returned path is related to DIRECTORY." + (if semanticdb-default-save-directory + (let ((file (cedet-directory-name-to-file-name directory))) + ;; Now create a filename for the cache file in + ;; ;`semanticdb-default-save-directory'. + (expand-file-name + file (file-name-as-directory semanticdb-default-save-directory))) + directory)) + +(defmethod semanticdb-cache-filename :STATIC + ((dbclass semanticdb-project-database-file) path) + "For DBCLASS, return a file to a cache file belonging to PATH. +This could be a cache file in the current directory, or an encoded file +name in a secondary directory." + ;; Use concat and not expand-file-name, because the dir part + ;; may include some of the file name. + (concat (semanticdb-file-name-directory dbclass path) + (semanticdb-file-name-non-directory dbclass))) + +(defmethod semanticdb-full-filename ((obj semanticdb-project-database-file)) + "Fetch the full filename that OBJ refers to." + (oref obj file)) + +;;; FLUSH OLD FILES +;; +(defun semanticdb-cleanup-cache-files (&optional noerror) + "Cleanup any cache files associated with directories that no longer exist. +Optional NOERROR prevents errors from being displayed." + (interactive) + (when (and (not semanticdb-default-save-directory) + (not noerror)) + (error "No default save directory for semantic-save files")) + + (when semanticdb-default-save-directory + + ;; Calculate all the cache files we have. + (let* ((regexp (regexp-quote semanticdb-default-file-name)) + (files (directory-files semanticdb-default-save-directory + t regexp)) + (orig nil) + (to-delete nil)) + (dolist (F files) + (setq orig (cedet-file-name-to-directory-name + (file-name-nondirectory F))) + (when (not (file-exists-p (file-name-directory orig))) + (setq to-delete (cons F to-delete)) + )) + (if to-delete + (save-window-excursion + (let ((buff (get-buffer-create "*Semanticdb Delete*"))) + (with-current-buffer buff + (erase-buffer) + (insert "The following Cache files appear to be obsolete.\n\n") + (dolist (F to-delete) + (insert F "\n"))) + (pop-to-buffer buff t t) + (fit-window-to-buffer (get-buffer-window buff) nil 1) + (when (y-or-n-p "Delete Old Cache Files? ") + (mapc (lambda (F) + (message "Deleting to %s..." F) + (delete-file F)) + to-delete) + (message "done.")) + )) + ;; No files to delete + (when (not noerror) + (message "No obsolete semanticdb.cache files.")) + )))) + +(provide 'semantic/db-file) + +;;; semanticdb-file.el ends here diff --git a/lisp/cedet/semantic/db-javascript.el b/lisp/cedet/semantic/db-javascript.el new file mode 100644 index 00000000000..dca2c38d4a6 --- /dev/null +++ b/lisp/cedet/semantic/db-javascript.el @@ -0,0 +1,310 @@ +;;; db-javascript.el --- Semantic database extensions for javascript + +;;; Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 +;;; Free Software Foundation, Inc. + +;; Author: Joakim Verona + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; Semanticdb database for Javascript. +;; +;; This is an omniscient database with a hard-coded list of symbols for +;; Javascript. See the doc at the end of this file for adding or modifying +;; the list of tags. +;; + +(require 'semantic/db-search) +(eval-when-compile + ;; For generic function searching. + (require 'eieio) + (require 'eieio-opt) + ) +;;; Code: +(defvar semanticdb-javascript-tags + '(("eval" function + (:arguments + (("x" variable nil nil nil))) + nil nil) + ("parseInt" function + (:arguments + (("string" variable nil nil nil) + ("radix" variable nil nil nil))) + nil nil) + ("parseFloat" function + (:arguments + (("string" variable nil nil nil))) + nil nil) + ("isNaN" function + (:arguments + (("number" variable nil nil nil))) + nil nil) + ("isFinite" function + (:arguments + (("number" variable nil nil nil))) + nil nil) + ("decodeURI" function + (:arguments + (("encodedURI" variable nil nil nil))) + nil nil) + ("decodeURIComponent" function + (:arguments + (("encodedURIComponent" variable nil nil nil))) + nil nil) + ("encodeURI" function + (:arguments + (("uri" variable nil nil nil))) + nil nil) + ("encodeURIComponent" function + (:arguments + (("uriComponent" variable nil nil nil))) + nil nil)) + "Hard-coded list of javascript tags for semanticdb. +See bottom of this file for instruction on managing this list.") + +;;; Classes: +(defclass semanticdb-table-javascript (semanticdb-search-results-table) + ((major-mode :initform javascript-mode) + ) + "A table for returning search results from javascript.") + +(defclass semanticdb-project-database-javascript + (semanticdb-project-database + eieio-singleton ;this db is for js globals, so singleton is apropriate + ) + ((new-table-class :initform semanticdb-table-javascript + :type class + :documentation + "New tables created for this database are of this class.") + ) + "Database representing javascript.") + +;; Create the database, and add it to searchable databases for javascript mode. +(defvar-mode-local javascript-mode semanticdb-project-system-databases + (list + (semanticdb-project-database-javascript "Javascript")) + "Search javascript for symbols.") + +;; NOTE: Be sure to modify this to the best advantage of your +;; language. +(defvar-mode-local javascript-mode semanticdb-find-default-throttle + '(project omniscience) + "Search project files, then search this omniscience database. +It is not necessary to to system or recursive searching because of +the omniscience database.") + +;;; Filename based methods +;; +(defmethod semanticdb-get-database-tables ((obj semanticdb-project-database-javascript)) + "For a javascript database, there are no explicit tables. +Create one of our special tables that can act as an intermediary." + ;; NOTE: This method overrides an accessor for the `tables' slot in + ;; a database. You can either construct your own (like tmp here + ;; or you can manage any number of tables. + + ;; We need to return something since there is always the "master table" + ;; The table can then answer file name type questions. + (when (not (slot-boundp obj 'tables)) + (let ((newtable (semanticdb-table-javascript "tmp"))) + (oset obj tables (list newtable)) + (oset newtable parent-db obj) + (oset newtable tags nil) + )) + (call-next-method) + ) + +(defmethod semanticdb-file-table ((obj semanticdb-project-database-javascript) filename) + "From OBJ, return FILENAME's associated table object." + ;; NOTE: See not for `semanticdb-get-database-tables'. + (car (semanticdb-get-database-tables obj)) + ) + +(defmethod semanticdb-get-tags ((table semanticdb-table-javascript )) + "Return the list of tags belonging to TABLE." + ;; NOTE: Omniscient databases probably don't want to keep large tabes + ;; lolly-gagging about. Keep internal Emacs tables empty and + ;; refer to alternate databases when you need something. + semanticdb-javascript-tags) + +(defmethod semanticdb-equivalent-mode ((table semanticdb-table-javascript) &optional buffer) + "Return non-nil if TABLE's mode is equivalent to BUFFER. +Equivalent modes are specified by by `semantic-equivalent-major-modes' +local variable." + (save-excursion + (set-buffer buffer) + (eq (or mode-local-active-mode major-mode) 'javascript-mode))) + +;;; Usage +;; +;; Unlike other tables, an omniscent database does not need to +;; be associated with a path. Use this routine to always add ourselves +;; to a search list. +(define-mode-local-override semanticdb-find-translate-path javascript-mode + (path brutish) + "Return a list of semanticdb tables asociated with PATH. +If brutish, do the default action. +If not brutish, do the default action, and append the system +database (if available.)" + (let ((default + ;; When we recurse, disable searching of system databases + ;; so that our Javascript database only shows up once when + ;; we append it in this iteration. + (let ((semanticdb-search-system-databases nil) + ) + (semanticdb-find-translate-path-default path brutish)))) + ;; Don't add anything if BRUTISH is on (it will be added in that fcn) + ;; or if we aren't supposed to search the system. + (if (or brutish (not semanticdb-search-system-databases)) + default + (let ((tables (apply #'append + (mapcar + (lambda (db) (semanticdb-get-database-tables db)) + semanticdb-project-system-databases)))) + (append default tables))))) + +;;; Search Overrides +;; +;; NOTE WHEN IMPLEMENTING: Be sure to add doc-string updates explaining +;; how your new search routines are implemented. +;; +(defun semanticdb-javascript-regexp-search (regexp) + "Search for REGEXP in our fixed list of javascript tags." + (let* ((tags semanticdb-javascript-tags) + (result nil)) + (while tags + (if (string-match regexp (caar tags)) + (setq result (cons (car tags) result))) + (setq tags (cdr tags))) + result)) + +(defmethod semanticdb-find-tags-by-name-method + ((table semanticdb-table-javascript) name &optional tags) + "Find all tags named NAME in TABLE. +Return a list of tags." + (if tags + ;; If TAGS are passed in, then we don't need to do work here. + (call-next-method) + (assoc-string name semanticdb-javascript-tags) + )) + +(defmethod semanticdb-find-tags-by-name-regexp-method + ((table semanticdb-table-javascript) regex &optional tags) + "Find all tags with name matching REGEX in TABLE. +Optional argument TAGS is a list of tags to search. +Return a list of tags." + (if tags (call-next-method) + ;; YOUR IMPLEMENTATION HERE + (semanticdb-javascript-regexp-search regex) + + )) + +(defmethod semanticdb-find-tags-for-completion-method + ((table semanticdb-table-javascript) prefix &optional tags) + "In TABLE, find all occurances of tags matching PREFIX. +Optional argument TAGS is a list of tags to search. +Returns a table of all matching tags." + (if tags (call-next-method) + ;; YOUR IMPLEMENTATION HERE + (semanticdb-javascript-regexp-search (concat "^" prefix ".*")) + )) + +(defmethod semanticdb-find-tags-by-class-method + ((table semanticdb-table-javascript) class &optional tags) + "In TABLE, find all occurances of tags of CLASS. +Optional argument TAGS is a list of tags to search. +Returns a table of all matching tags." + (if tags (call-next-method) + ;; YOUR IMPLEMENTATION HERE + ;; + ;; Note: This search method could be considered optional in an + ;; omniscient database. It may be unwise to return all tags + ;; that exist for a language that are a variable or function. + ;; + ;; If it is optional, you can just delete this method. + nil)) + +;;; Deep Searches +;; +;; If your language does not have a `deep' concept, these can be left +;; alone, otherwise replace with implementations similar to those +;; above. +;; +(defmethod semanticdb-deep-find-tags-by-name-method + ((table semanticdb-table-javascript) name &optional tags) + "Find all tags name NAME in TABLE. +Optional argument TAGS is a list of tags t +Like `semanticdb-find-tags-by-name-method' for javascript." + (semanticdb-find-tags-by-name-method table name tags)) + +(defmethod semanticdb-deep-find-tags-by-name-regexp-method + ((table semanticdb-table-javascript) regex &optional tags) + "Find all tags with name matching REGEX in TABLE. +Optional argument TAGS is a list of tags to search. +Like `semanticdb-find-tags-by-name-method' for javascript." + (semanticdb-find-tags-by-name-regexp-method table regex tags)) + +(defmethod semanticdb-deep-find-tags-for-completion-method + ((table semanticdb-table-javascript) prefix &optional tags) + "In TABLE, find all occurances of tags matching PREFIX. +Optional argument TAGS is a list of tags to search. +Like `semanticdb-find-tags-for-completion-method' for javascript." + (semanticdb-find-tags-for-completion-method table prefix tags)) + +;;; Advanced Searches +;; +(defmethod semanticdb-find-tags-external-children-of-type-method + ((table semanticdb-table-javascript) type &optional tags) + "Find all nonterminals which are child elements of TYPE +Optional argument TAGS is a list of tags to search. +Return a list of tags." + (if tags (call-next-method) + ;; YOUR IMPLEMENTATION HERE + ;; + ;; OPTIONAL: This could be considered an optional function. It is + ;; used for `semantic-adopt-external-members' and may not + ;; be possible to do in your language. + ;; + ;; If it is optional, you can just delete this method. + )) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defun semanticdb-javascript-strip-tags (tags) + "Strip TAGS from overlays and reparse symbols." + (cond ((and (consp tags) (eq 'reparse-symbol (car tags))) + nil) + ((overlayp tags) nil) + ((atom tags) tags) + (t (cons (semanticdb-javascript-strip-tags + (car tags)) (semanticdb-javascript-strip-tags + (cdr tags)))))) + +;this list was made from a javascript file, and the above function +;; function eval(x){} +;; function parseInt(string,radix){} +;; function parseFloat(string){} +;; function isNaN(number){} +;; function isFinite(number){} +;; function decodeURI(encodedURI){} +;; function decodeURIComponent (encodedURIComponent){} +;; function encodeURI (uri){} +;; function encodeURIComponent (uriComponent){} + + +(provide 'semantic/db-el) + +;;; semanticdb-el.el ends here diff --git a/lisp/cedet/semantic/db-search.el b/lisp/cedet/semantic/db-search.el new file mode 100644 index 00000000000..acfb788fe16 --- /dev/null +++ b/lisp/cedet/semantic/db-search.el @@ -0,0 +1,451 @@ +;;; db-search.el --- Searching through semantic databases. + +;;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2008, 2009 +;;; Free Software Foundation, Inc. + +;; Author: Eric M. Ludlam + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; NOTE: THESE APIs ARE OBSOLETE: +;; +;; Databases of various forms can all be searched. These routines +;; cover many common forms of searching. +;; +;; There are three types of searches that can be implemented: +;; +;; Basic Search: +;; These searches allow searching on specific attributes of tags, +;; such as name or type. +;; +;; Advanced Search: +;; These are searches that were needed to accomplish some tasks +;; during in utilities. Advanced searches include matching methods +;; defined outside some parent class. +;; +;; The reason for advanced searches are so that external +;; repositories such as the Emacs obarray, or java .class files can +;; quickly answer these needed questions without dumping the entire +;; symbol list into Emacs for a regular semanticdb search. +;; +;; Generic Search: +;; The generic search, `semanticdb-find-nonterminal-by-function' +;; accepts a Emacs Lisp predicate that tests tags in Semantic +;; format. Most external searches cannot perform this search. + +(require 'semantic/db) +(require 'semantic/find) + +;;; Code: +;; +;;; Classes: + +;; @TODO MOVE THIS CLASS? +(defclass semanticdb-search-results-table (semanticdb-abstract-table) + ( + ) + "Table used for search results when there is no file or table association. +Examples include search results from external sources such as from +Emacs' own symbol table, or from external libraries.") + +(defmethod semanticdb-refresh-table ((obj semanticdb-search-results-table) &optional force) + "If the tag list associated with OBJ is loaded, refresh it. +This will call `semantic-fetch-tags' if that file is in memory." + nil) + +;;; Utils +;; +;; Convenience routines for searches +(defun semanticdb-collect-find-results (result-in-databases + result-finding-function + ignore-system + find-file-on-match) + "OBSOLETE: +Collect results across RESULT-IN-DATABASES for RESULT-FINDING-FUNCTION. +If RESULT-IN-DATABASES is nil, search a range of associated databases +calculated by `semanticdb-current-database-list'. +RESULT-IN-DATABASES is a list of variable `semanticdb-project-database' +objects. +RESULT-FINDING-FUNCTION should accept one argument, the database being searched. +Argument IGNORE-SYSTEM specifies if any available system databases should +be ignored, or searched. +Argument FIND-FILE-ON-MATCH indicates that the found databases +should be capable of doing so." + (if (not (listp result-in-databases)) + (signal 'wrong-type-argument (list 'listp result-in-databases))) + (let* ((semanticdb-search-system-databases + (if ignore-system + nil + semanticdb-search-system-databases)) + (dbs (or result-in-databases + ;; Calculate what database to use. + ;; Something simple and dumb for now. + (or (semanticdb-current-database-list) + (list (semanticdb-current-database))))) + (case-fold-search semantic-case-fold) + (res (mapcar + (lambda (db) + (if (or (not find-file-on-match) + (not (child-of-class-p + (oref db new-table-class) + semanticdb-search-results-table))) + (funcall result-finding-function db))) + dbs)) + out) + ;; Flatten the list. The DB is unimportant at this stage. + (setq res (apply 'append res)) + (setq out nil) + ;; Move across results, and throw out empties. + (while res + (if (car res) + (setq out (cons (car res) out))) + (setq res (cdr res))) + ;; Results + out)) + +;;; Programatic interfaces +;; +;; These routines all perform different types of searches, and are +;; interfaces to the database methods used to also perform those searches. + +(defun semanticdb-find-nonterminal-by-token + (token &optional databases search-parts search-includes diff-mode find-file-match ignore-system) + "OBSOLETE: +Find all occurances of nonterminals with token TOKEN in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES, DIFF-MODE, FIND-FILE-MATCH and IGNORE-SYSTEM. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-collect-find-results + databases + (lambda (db) + (semanticdb-find-nonterminal-by-token-method + db token search-parts search-includes diff-mode find-file-match)) + ignore-system + find-file-match)) +(make-obsolete 'semanticdb-find-nonterminal-by-token + "Please don't use this function") + +(defun semanticdb-find-nonterminal-by-name + (name &optional databases search-parts search-includes diff-mode find-file-match ignore-system) + "OBSOLETE: +Find all occurances of nonterminals with name NAME in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES, DIFF-MODE, FIND-FILE-MATCH and IGNORE-SYSTEM. +Return a list ((DB-TABLE . TOKEN) ...)." + (semanticdb-collect-find-results + databases + (lambda (db) + (semanticdb-find-nonterminal-by-name-method + db name search-parts search-includes diff-mode find-file-match)) + ignore-system + find-file-match)) +(make-obsolete 'semanticdb-find-nonterminal-by-name + "Please don't use this function") + +(defun semanticdb-find-nonterminal-by-name-regexp + (regex &optional databases search-parts search-includes diff-mode find-file-match ignore-system) + "OBSOLETE: +Find all occurances of nonterminals with name matching REGEX in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES DIFF-MODE, FIND-FILE-MATCH and IGNORE-SYSTEM. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-collect-find-results + databases + (lambda (db) + (semanticdb-find-nonterminal-by-name-regexp-method + db regex search-parts search-includes diff-mode find-file-match)) + ignore-system + find-file-match)) +(make-obsolete 'semanticdb-find-nonterminal-by-name-regexp + "Please don't use this function") + + +(defun semanticdb-find-nonterminal-by-type + (type &optional databases search-parts search-includes diff-mode find-file-match ignore-system) + "OBSOLETE: +Find all nonterminals with a type of TYPE in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES DIFF-MODE, FIND-FILE-MATCH and IGNORE-SYSTEM. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-collect-find-results + databases + (lambda (db) + (semanticdb-find-nonterminal-by-type-method + db type search-parts search-includes diff-mode find-file-match)) + ignore-system + find-file-match)) +(make-obsolete 'semanticdb-find-nonterminal-by-type + "Please don't use this function") + + +(defun semanticdb-find-nonterminal-by-property + (property value &optional databases search-parts search-includes diff-mode find-file-match ignore-system) + "OBSOLETE: +Find all nonterminals with a PROPERTY equal to VALUE in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES DIFF-MODE, FIND-FILE-MATCH and IGNORE-SYSTEM. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-collect-find-results + databases + (lambda (db) + (semanticdb-find-nonterminal-by-property-method + db property value search-parts search-includes diff-mode find-file-match)) + ignore-system + find-file-match)) +(make-obsolete 'semanticdb-find-nonterminal-by-property + "Please don't use this function") + +(defun semanticdb-find-nonterminal-by-extra-spec + (spec &optional databases search-parts search-includes diff-mode find-file-match ignore-system) + "OBSOLETE: +Find all nonterminals with a SPEC in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES DIFF-MODE, FIND-FILE-MATCH and IGNORE-SYSTEM. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-collect-find-results + databases + (lambda (db) + (semanticdb-find-nonterminal-by-extra-spec-method + db spec search-parts search-includes diff-mode find-file-match)) + ignore-system + find-file-match)) +(make-obsolete 'semanticdb-find-nonterminal-by-extra-spec + "Please don't use this function") + +(defun semanticdb-find-nonterminal-by-extra-spec-value + (spec value &optional databases search-parts search-includes diff-mode find-file-match ignore-system) + "OBSOLETE: +Find all nonterminals with a SPEC equal to VALUE in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES DIFF-MODE, FIND-FILE-MATCH and IGNORE-SYSTEM. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-collect-find-results + databases + (lambda (db) + (semanticdb-find-nonterminal-by-extra-spec-value-method + db spec value search-parts search-includes diff-mode find-file-match)) + ignore-system + find-file-match)) +(make-obsolete 'semanticdb-find-nonterminal-by-extra-spec-value + "Please don't use this function") + +;;; Advanced Search Routines +;; +(defun semanticdb-find-nonterminal-external-children-of-type + (type &optional databases search-parts search-includes diff-mode find-file-match ignore-system) + "OBSOLETE: +Find all nonterminals which are child elements of TYPE. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES DIFF-MODE, FIND-FILE-MATCH and IGNORE-SYSTEM. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-collect-find-results + databases + (lambda (db) + (semanticdb-find-nonterminal-external-children-of-type-method + db type search-parts search-includes diff-mode find-file-match)) + ignore-system + find-file-match)) + +;;; Generic Search routine +;; + +(defun semanticdb-find-nonterminal-by-function + (function &optional databases search-parts search-includes diff-mode find-file-match ignore-system) + "OBSOLETE: +Find all occurances of nonterminals which match FUNCTION. +Search in all DATABASES. If DATABASES is nil, search a range of +associated databases calculated `semanticdb-current-database-list' and +DATABASES is a list of variable `semanticdb-project-database' objects. +When SEARCH-PARTS is non-nil the search will include children of tags. +When SEARCH-INCLUDES is non-nil, the search will include dependency files. +When DIFF-MODE is non-nil, search databases which are of a different mode. +A Mode is the `major-mode' that file was in when it was last parsed. +When FIND-FILE-MATCH is non-nil, the make sure any found token's file is +in an Emacs buffer. +When IGNORE-SYSTEM is non-nil, system libraries are not searched. +Return a list ((DB-TABLE . TOKEN-OR-TOKEN-LIST) ...)." + (semanticdb-collect-find-results + databases + (lambda (db) + (semanticdb-find-nonterminal-by-function-method + db function search-parts search-includes diff-mode find-file-match)) + ignore-system + find-file-match)) + +;;; Search Methods +;; +;; These are the base routines for searching semantic databases. +;; Overload these with your subclasses to participate in the searching +;; mechanism. +(defmethod semanticdb-find-nonterminal-by-token-method + ((database semanticdb-project-database) token search-parts search-includes diff-mode find-file-match) + "OBSOLETE: +In DB, find all occurances of nonterminals with token TOKEN in databases. +See `semanticdb-find-nonterminal-by-function-method' for details on, +SEARCH-PARTS, SEARCH-INCLUDES, DIFF-MODE, and FIND-FILE-MATCH. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (let ((goofy-token-name token)) + (semanticdb-find-nonterminal-by-function-method + database (lambda (stream sp si) + (semantic-brute-find-tag-by-class goofy-token-name stream sp si)) + search-parts search-includes diff-mode find-file-match))) + +(defmethod semanticdb-find-nonterminal-by-name-method + ((database semanticdb-project-database) name search-parts search-includes diff-mode find-file-match) + "OBSOLETE: +Find all occurances of nonterminals with name NAME in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES, DIFF-MODE, and FIND-FILE-MATCH. +Return a list ((DB-TABLE . TOKEN) ...)." + (semanticdb-find-nonterminal-by-function-method + database + (lambda (stream sp si) + (semantic-brute-find-first-tag-by-name name stream sp si)) + search-parts search-includes diff-mode find-file-match)) + +(defmethod semanticdb-find-nonterminal-by-name-regexp-method + ((database semanticdb-project-database) regex search-parts search-includes diff-mode find-file-match) + "OBSOLETE: +Find all occurances of nonterminals with name matching REGEX in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES DIFF-MODE, and FIND-FILE-MATCH. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-find-nonterminal-by-function-method + database + (lambda (stream sp si) + (semantic-brute-find-tag-by-name-regexp regex stream sp si)) + search-parts search-includes diff-mode find-file-match)) + +(defmethod semanticdb-find-nonterminal-by-type-method + ((database semanticdb-project-database) type search-parts search-includes diff-mode find-file-match) + "OBSOLETE: +Find all nonterminals with a type of TYPE in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES DIFF-MODE, and FIND-FILE-MATCH. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-find-nonterminal-by-function-method + database + (lambda (stream sp si) + (semantic-brute-find-tag-by-type type stream sp si)) + search-parts search-includes diff-mode find-file-match)) + +(defmethod semanticdb-find-nonterminal-by-property-method + ((database semanticdb-project-database) property value search-parts search-includes diff-mode find-file-match) + "OBSOLETE: +Find all nonterminals with a PROPERTY equal to VALUE in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES DIFF-MODE, and FIND-FILE-MATCH. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-find-nonterminal-by-function-method + database + (lambda (stream sp si) + (semantic-brute-find-tag-by-property property value stream sp si)) + search-parts search-includes diff-mode find-file-match)) + +(defmethod semanticdb-find-nonterminal-by-extra-spec-method + ((database semanticdb-project-database) spec search-parts search-includes diff-mode find-file-match) + "OBSOLETE: +Find all nonterminals with a SPEC in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES DIFF-MODE, and FIND-FILE-MATCH. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-find-nonterminal-by-function-method + database + (lambda (stream sp si) + (semantic-brute-find-tag-by-attribute spec stream sp si)) + search-parts search-includes diff-mode find-file-match)) + +(defmethod semanticdb-find-nonterminal-by-extra-spec-value-method + ((database semanticdb-project-database) spec value search-parts search-includes diff-mode find-file-match) + "OBSOLETE: +Find all nonterminals with a SPEC equal to VALUE in databases. +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES DIFF-MODE, and FIND-FILE-MATCH. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-find-nonterminal-by-function-method + database + (lambda (stream sp si) + (semantic-brute-find-tag-by-attribute-value spec value stream sp si)) + search-parts search-includes diff-mode find-file-match)) + +;;; Advanced Searches +;; +(defmethod semanticdb-find-nonterminal-external-children-of-type-method + ((database semanticdb-project-database) type search-parts search-includes diff-mode find-file-match) + "OBSOLETE: +Find all nonterminals which are child elements of TYPE +See `semanticdb-find-nonterminal-by-function' for details on DATABASES, +SEARCH-PARTS, SEARCH-INCLUDES DIFF-MODE, FIND-FILE-MATCH and IGNORE-SYSTEM. +Return a list ((DB-TABLE . TOKEN-LIST) ...)." + (semanticdb-find-nonterminal-by-function-method + database + `(lambda (stream sp si) + (semantic-brute-find-tag-by-function + (lambda (tok) + (let ((p (semantic-nonterminal-external-member-parent tok))) + (and (stringp p) (string= ,type p))) + ) + stream sp si)) + nil nil t)) + +;;; Generic Search +;; +(defmethod semanticdb-find-nonterminal-by-function-method + ((database semanticdb-project-database) + function &optional search-parts search-includes diff-mode find-file-match) + "OBSOLETE: +In DATABASE, find all occurances of nonterminals which match FUNCTION. +When SEARCH-PARTS is non-nil the search will include children of tags. +When SEARCH-INCLUDES is non-nil, the search will include dependency files. +When DIFF-MODE is non-nil, search databases which are of a different mode. +A mode is the `major-mode' that file was in when it was last parsed. +When FIND-FILE-MATCH is non-nil, the make sure any found token's file is +in an Emacs buffer. +Return a list of matches." + (let* ((ret nil) + (files (semanticdb-get-database-tables database)) + (found nil) + (orig-buffer (current-buffer))) + (while files + (when (or diff-mode + (semanticdb-equivalent-mode (car files) orig-buffer)) + ;; This can cause unneeded refreshes while typing with + ;; senator-eldoc mode. + ;;(semanticdb-refresh-table (car files)) + (setq found (funcall function + (semanticdb-get-tags (car files)) + search-parts + search-includes + ))) + (if found + (progn + ;; When something is found, make sure we read in that buffer if it + ;; had not already been loaded. + (if find-file-match + (save-excursion (semanticdb-set-buffer (car files)))) + ;; In theory, the database is up-to-date with what is in the file, and + ;; these tags are ready to go. + ;; There is a bug lurking here I don't have time to fix. + (setq ret (cons (cons (car files) found) ret)) + (setq found nil))) + (setq files (cdr files))) + (nreverse ret))) + +(provide 'semantic/db-search) + +;;; semanticdb-search.el ends here diff --git a/lisp/cedet/semantic/db-typecache.el b/lisp/cedet/semantic/db-typecache.el new file mode 100644 index 00000000000..689e6d903f0 --- /dev/null +++ b/lisp/cedet/semantic/db-typecache.el @@ -0,0 +1,585 @@ +;;; db-typecache.el --- Manage Datatypes + +;; Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc. + +;; Author: Eric M. Ludlam + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; Manage a datatype cache. +;; +;; For typed languages like C++ collect all known types from various +;; headers, merge namespaces, and expunge duplicates. +;; +;; It is likely this feature will only be needed for C/C++. + +(require 'semantic/db) +(require 'semantic/db-find) + +;;; Code: + + +;;; TABLE TYPECACHE +(defclass semanticdb-typecache () + ((filestream :initform nil + :documentation + "Fully sorted/merged list of tags within this buffer.") + (includestream :initform nil + :documentation + "Fully sorted/merged list of tags from this file's includes list.") + (stream :initform nil + :documentation + "The searchable tag stream for this cache. +NOTE: Can I get rid of this? Use a hashtable instead?") + (dependants :initform nil + :documentation + "Any other object that is dependent on typecache results. +Said object must support `semantic-reset' methods.") + ;; @todo - add some sort of fast-hash. + ;; @note - Rebuilds in large projects already take a while, and the + ;; actual searches are pretty fast. Really needed? + ) + "Structure for maintaining a typecache.") + +(defmethod semantic-reset ((tc semanticdb-typecache)) + "Reset the object IDX." + (oset tc filestream nil) + (oset tc includestream nil) + + (oset tc stream nil) + + (mapc 'semantic-reset (oref tc dependants)) + (oset tc dependants nil) + ) + +(defmethod semanticdb-typecache-notify-reset ((tc semanticdb-typecache)) + "Do a reset from a notify from a table we depend on." + (oset tc includestream nil) + (mapc 'semantic-reset (oref tc dependants)) + (oset tc dependants nil) + ) + +(defmethod semanticdb-partial-synchronize ((tc semanticdb-typecache) + new-tags) + "Reset the typecache based on a partial reparse." + (when (semantic-find-tags-by-class 'include new-tags) + (oset tc includestream nil) + (mapc 'semantic-reset (oref tc dependants)) + (oset tc dependants nil) + ) + + (when (semantic-find-tags-by-class 'type new-tags) + ;; Reset our index + (oset tc filestream nil) + t ;; Return true, our core file tags have changed in a relavant way. + ) + + ;; NO CODE HERE + ) + +(defun semanticdb-typecache-add-dependant (dep) + "Add into the local typecache a dependant DEP." + (let* ((table semanticdb-current-table) + ;;(idx (semanticdb-get-table-index table)) + (cache (semanticdb-get-typecache table)) + ) + (object-add-to-list cache 'dependants dep))) + +(defun semanticdb-typecache-length(thing) + "How long is THING? +Debugging function." + (cond ((semanticdb-typecache-child-p thing) + (length (oref thing stream))) + ((semantic-tag-p thing) + (length (semantic-tag-type-members thing))) + ((and (listp thing) (semantic-tag-p (car thing))) + (length thing)) + ((null thing) + 0) + (t -1) )) + + +(defmethod semanticdb-get-typecache ((table semanticdb-abstract-table)) + "Retrieve the typecache from the semanticdb TABLE. +If there is no table, create one, and fill it in." + (semanticdb-refresh-table table) + (let* ((idx (semanticdb-get-table-index table)) + (cache (oref idx type-cache)) + ) + + ;; Make sure we have a cache object in the DB index. + (when (not cache) + ;; The object won't change as we fill it with stuff. + (setq cache (semanticdb-typecache (semanticdb-full-filename table))) + (oset idx type-cache cache)) + + cache)) + +(defmethod semanticdb-have-typecache-p ((table semanticdb-abstract-table)) + "Return non-nil (the typecache) if TABLE has a pre-calculated typecache." + (let* ((idx (semanticdb-get-table-index table))) + (oref idx type-cache))) + + +;;; DATABASE TYPECACHE +;; +;; A full database can cache the types across its files. +;; +;; Unlike file based caches, this one is a bit simpler, and just needs +;; to get reset when a table gets updated. + +(defclass semanticdb-database-typecache (semanticdb-abstract-db-cache) + ((stream :initform nil + :documentation + "The searchable tag stream for this cache.") + ) + "Structure for maintaining a typecache.") + +(defmethod semantic-reset ((tc semanticdb-database-typecache)) + "Reset the object IDX." + (oset tc stream nil) + ) + +(defmethod semanticdb-synchronize ((cache semanticdb-database-typecache) + new-tags) + "Synchronize a CACHE with some NEW-TAGS." + ) + +(defmethod semanticdb-partial-synchronize ((cache semanticdb-database-typecache) + new-tags) + "Synchronize a CACHE with some changed NEW-TAGS." + ) + +(defmethod semanticdb-get-typecache ((db semanticdb-project-database)) + "Retrieve the typecache from the semantic database DB. +If there is no table, create one, and fill it in." + (semanticdb-cache-get db semanticdb-database-typecache) + ) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; MERGING +;; +;; Managing long streams of tags representing data types. +;; +(defun semanticdb-typecache-apply-filename (file stream) + "Apply the filename FILE to all tags in STREAM." + (let ((new nil)) + (while stream + (setq new (cons (semantic-tag-copy (car stream) nil file) + new)) + ;The below is handled by the tag-copy fcn. + ;(semantic--tag-put-property (car new) :filename file) + (setq stream (cdr stream))) + (nreverse new))) + + +(defsubst semanticdb-typecache-safe-tag-members (tag) + "Return a list of members for TAG that are safe to permute." + (let ((mem (semantic-tag-type-members tag)) + (fname (semantic-tag-file-name tag))) + (if fname + (setq mem (semanticdb-typecache-apply-filename fname mem)) + (copy-sequence mem)))) + +(defsubst semanticdb-typecache-safe-tag-list (tags table) + "Make the tag list TAGS found in TABLE safe for the typecache. +Adds a filename and copies the tags." + (semanticdb-typecache-apply-filename + (semanticdb-full-filename table) + tags)) + +(defun semanticdb-typecache-merge-streams (cache1 cache2) + "Merge into CACHE1 and CACHE2 together. The Caches will be merged in place." + (if (or (and (not cache1) (not cache2)) + (and (not (cdr cache1)) (not cache2)) + (and (not cache1) (not (cdr cache2)))) + ;; If all caches are empty OR + ;; cache1 is length 1 and no cache2 OR + ;; no cache1 and length 1 cache2 + ;; + ;; then just return the cache, and skip all this merging stuff. + (or cache1 cache2) + + ;; Assume we always have datatypes, as this typecache isn't really + ;; useful without a typed language. + (let ((S (semantic-sort-tags-by-name-then-type-increasing + ;; I used to use append, but it copied cache1 but not cache2. + ;; Since sort was permuting cache2, I already had to make sure + ;; the caches were permute-safe. Might as well use nconc here. + (nconc cache1 cache2))) + (ans nil) + (next nil) + (prev nil) + (type nil)) + ;; With all the tags in order, we can loop over them, and when + ;; two have the same name, we can either throw one away, or construct + ;; a fresh new tag merging the items together. + (while S + (setq prev (car ans)) + (setq next (car S)) + (if (or + ;; CASE 1 - First item + (null prev) + ;; CASE 2 - New name + (not (string= (semantic-tag-name next) + (semantic-tag-name prev)))) + (setq ans (cons next ans)) + ;; ELSE - We have a NAME match. + (setq type (semantic-tag-type next)) + (if (semantic-tag-of-type-p prev type) ; Are they the same datatype + ;; Same Class, we can do a merge. + (cond + ((and (semantic-tag-of-class-p next 'type) + (string= type "namespace")) + ;; Namespaces - merge the children together. + (setcar ans + (semantic-tag-new-type + (semantic-tag-name prev) ; - they are the same + "namespace" ; - we know this as fact + (semanticdb-typecache-merge-streams + (semanticdb-typecache-safe-tag-members prev) + (semanticdb-typecache-safe-tag-members next)) + nil ; - no attributes + )) + ;; Make sure we mark this as a fake tag. + (semantic-tag-set-faux (car ans)) + ) + ((semantic-tag-prototype-p next) + ;; NEXT is a prototype... so keep previous. + nil ; - keep prev, do nothing + ) + ((semantic-tag-prototype-p prev) + ;; PREV is a prototype, but not next.. so keep NEXT. + ;; setcar - set by side-effect on top of prev + (setcar ans next) + ) + (t + ;;(message "Don't know how to merge %s. Keeping first entry." (semantic-tag-name next)) + )) + ;; Not same class... but same name + ;(message "Same name, different type: %s, %s!=%s" + ; (semantic-tag-name next) + ; (semantic-tag-type next) + ; (semantic-tag-type prev)) + (setq ans (cons next ans)) + )) + (setq S (cdr S))) + (nreverse ans)))) + +;;; Refresh / Query API +;; +;; Queries that can be made for the typecache. +(defmethod semanticdb-typecache-file-tags ((table semanticdb-abstract-table)) + "No tags available from non-file based tables." + nil) + +(defmethod semanticdb-typecache-file-tags ((table semanticdb-table)) + "Update the typecache for TABLE, and return the file-tags. +File-tags are those that belong to this file only, and excludes +all included files." + (let* (;(idx (semanticdb-get-table-index table)) + (cache (semanticdb-get-typecache table)) + ) + + ;; Make sure our file-tags list is up to date. + (when (not (oref cache filestream)) + (let ((tags (semantic-find-tags-by-class 'type table))) + (when tags + (setq tags (semanticdb-typecache-safe-tag-list tags table)) + (oset cache filestream (semanticdb-typecache-merge-streams tags nil))))) + + ;; Return our cache. + (oref cache filestream) + )) + +(defmethod semanticdb-typecache-include-tags ((table semanticdb-abstract-table)) + "No tags available from non-file based tables." + nil) + +(defmethod semanticdb-typecache-include-tags ((table semanticdb-table)) + "Update the typecache for TABLE, and return the merged types from the include tags. +Include-tags are the tags brought in via includes, all merged together into +a master list." + (let* ((cache (semanticdb-get-typecache table)) + ) + + ;; Make sure our file-tags list is up to date. + (when (not (oref cache includestream)) + (let (;; Calc the path first. This will have a nice side -effect of + ;; getting the cache refreshed if a refresh is needed. Most of the + ;; time this value is itself cached, so the query is fast. + (incpath (semanticdb-find-translate-path table nil)) + (incstream nil)) + ;; Get the translated path, and extract all the type tags, then merge + ;; them all together. + (dolist (i incpath) + ;; don't include ourselves in this crazy list. + (when (and i (not (eq i table)) + ;; @todo - This eieio fcn can be slow! Do I need it? + ;; (semanticdb-table-child-p i) + ) + (setq incstream + (semanticdb-typecache-merge-streams + incstream + ;; Getting the cache from this table will also cause this + ;; file to update it's cache from it's decendants. + ;; + ;; In theory, caches are only built for most includes + ;; only once (in the loop before this one), so this ends + ;; up being super fast as we edit our file. + (copy-sequence + (semanticdb-typecache-file-tags i)))) + )) + + ;; Save... + (oset cache includestream incstream))) + + ;; Return our cache. + (oref cache includestream) + )) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Search Routines +;; +(define-overloadable-function semanticdb-typecache-find (type &optional path find-file-match) + "Search the typecache for TYPE in PATH. +If type is a string, split the string, and search for the parts. +If type is a list, treat the type as a pre-split string. +PATH can be nil for the current buffer, or a semanticdb table. +FIND-FILE-MATCH is non-nil to force all found tags to be loaded into a buffer.") + +(defun semanticdb-typecache-find-default (type &optional path find-file-match) + "Default implementation of `semanticdb-typecache-find'. +TYPE is the datatype to find. +PATH is the search path.. which should be one table object. +If FIND-FILE-MATCH is non-nil, then force the file belonging to the +found tag to be loaded." + (semanticdb-typecache-find-method (or path semanticdb-current-table) + type find-file-match)) + +(defun semanticdb-typecache-find-by-name-helper (name table) + "Find the tag with NAME in TABLE, which is from a typecache. +If more than one tag has NAME in TABLE, we will prefer the tag that +is of class 'type." + (let* ((names (semantic-find-tags-by-name name table)) + (types (semantic-find-tags-by-class 'type names))) + (or (car-safe types) (car-safe names)))) + +(defmethod semanticdb-typecache-find-method ((table semanticdb-abstract-table) + type find-file-match) + "Search the typecache in TABLE for the datatype TYPE. +If type is a string, split the string, and search for the parts. +If type is a list, treat the type as a pre-split string. +If FIND-FILE-MATCH is non-nil, then force the file belonging to the +found tag to be loaded." + ;; convert string to a list. + (when (stringp type) (setq type (semantic-analyze-split-name type))) + (when (stringp type) (setq type (list type))) + + ;; Search for the list in our typecache. + (let* ((file (semanticdb-typecache-file-tags table)) + (inc (semanticdb-typecache-include-tags table)) + (stream nil) + (f-ans nil) + (i-ans nil) + (ans nil) + (notdone t) + (lastfile nil) + (thisfile nil) + (lastans nil) + (calculated-scope nil) + ) + ;; 1) Find first symbol in the two master lists and then merge + ;; the found streams. + + ;; We stripped duplicates, so these will be super-fast! + (setq f-ans (semantic-find-first-tag-by-name (car type) file)) + (setq i-ans (semantic-find-first-tag-by-name (car type) inc)) + (if (and f-ans i-ans) + (progn + ;; This trick merges the two identified tags, making sure our lists are + ;; complete. The second find then gets the new 'master' from the list of 2. + (setq ans (semanticdb-typecache-merge-streams (list f-ans) (list i-ans))) + (setq ans (semantic-find-first-tag-by-name (car type) ans)) + ) + + ;; The answers are already sorted and merged, so if one misses, + ;; no need to do any special work. + (setq ans (or f-ans i-ans))) + + ;; 2) Loop over the remaining parts. + (while (and type notdone) + + ;; For pass > 1, stream will be non-nil, so do a search, otherwise + ;; ans is from outside the loop. + (when stream + (setq ans (semanticdb-typecache-find-by-name-helper (car type) stream)) + + ;; NOTE: The below test to make sure we get a type is only relevant + ;; for the SECOND pass or later. The first pass can only ever + ;; find a type/namespace because everything else is excluded. + + ;; If this is not the last entry from the list, then it + ;; must be a type or a namespace. Lets double check. + (when (cdr type) + + ;; From above, there is only one tag in ans, and we prefer + ;; types. + (when (not (semantic-tag-of-class-p ans 'type)) + + (setq ans nil))) + ) + + (push ans calculated-scope) + + ;; Track most recent file. + (setq thisfile (semantic-tag-file-name ans)) + (when (and thisfile (stringp thisfile)) + (setq lastfile thisfile)) + + ;; If we have a miss, exit, otherwise, update the stream to + ;; the next set of members. + (if (not ans) + (setq notdone nil) + (setq stream (semantic-tag-type-members ans))) + + (setq lastans ans + ans nil + type (cdr type))) + + (if (or type (not notdone)) + ;; If there is stuff left over, then we failed. Just return + ;; nothing. + nil + + ;; We finished, so return everything. + + (if (and find-file-match lastfile) + ;; This won't liven up the tag since we have a copy, but + ;; we ought to be able to get there and go to the right line. + (find-file-noselect lastfile) + ;; We don't want to find-file match, so instead lets + ;; push the filename onto the return tag. + (when lastans + (setq lastans (semantic-tag-copy lastans nil lastfile)) + ;; We used to do the below, but we would erroneously be putting + ;; attributes on tags being shred with other lists. + ;;(semantic--tag-put-property lastans :filename lastfile) + ) + ) + + (if (and lastans calculated-scope) + + ;; Put our discovered scope into the tag if we have a tag + (semantic-scope-tag-clone-with-scope + lastans (reverse (cdr calculated-scope))) + + ;; Else, just return + lastans + )))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; BRUTISH Typecache +;; +;; Routines for a typecache that crosses all tables in a given database +;; for a matching major-mode. +(defmethod semanticdb-typecache-for-database ((db semanticdb-project-database) + &optional mode) + "Return the typecache for the project database DB. +If there isn't one, create it. +" + (let ((lmode (or mode major-mode)) + (cache (semanticdb-get-typecache db)) + (stream nil) + ) + (dolist (table (semanticdb-get-database-tables db)) + (when (eq lmode (oref table :major-mode)) + (setq stream + (semanticdb-typecache-merge-streams + stream + (copy-sequence + (semanticdb-typecache-file-tags table)))) + )) + (oset cache stream stream) + cache)) + +(defun semanticdb-typecache-refresh-for-buffer (buffer) + "Refresh the typecache for BUFFER." + (save-excursion + (set-buffer buffer) + (let* ((tab semanticdb-current-table) + ;(idx (semanticdb-get-table-index tab)) + (tc (semanticdb-get-typecache tab))) + (semanticdb-typecache-file-tags tab) + (semanticdb-typecache-include-tags tab) + tc))) + + +;;; DEBUG +;; +(defun semanticdb-typecache-complete-flush () + "Flush all typecaches referenced by the current buffer." + (interactive) + (let* ((path (semanticdb-find-translate-path nil nil))) + (dolist (P path) + (oset P pointmax nil) + (semantic-reset (semanticdb-get-typecache P))))) + +(defun semanticdb-typecache-dump () + "Dump the typecache for the current buffer." + (interactive) + (require 'data-debug) + (let* ((start (current-time)) + (tc (semanticdb-typecache-refresh-for-buffer (current-buffer))) + (end (current-time)) + ) + (data-debug-new-buffer "*TypeCache ADEBUG*") + (message "Calculating Cache took %.2f seconds." + (semantic-elapsed-time start end)) + + (data-debug-insert-thing tc "]" "") + + )) + +(defun semanticdb-db-typecache-dump () + "Dump the typecache for the current buffer's database." + (interactive) + (require 'data-debug) + (let* ((tab semanticdb-current-table) + (idx (semanticdb-get-table-index tab)) + (junk (oset idx type-cache nil)) ;; flush! + (start (current-time)) + (tc (semanticdb-typecache-for-database (oref tab parent-db))) + (end (current-time)) + ) + (data-debug-new-buffer "*TypeCache ADEBUG*") + (message "Calculating Cache took %.2f seconds." + (semantic-elapsed-time start end)) + + (data-debug-insert-thing tc "]" "") + + )) + + +(provide 'semantic/db-typecache) +;;; semanticdb-typecache.el ends here diff --git a/lisp/cedet/semantic/dep.el b/lisp/cedet/semantic/dep.el new file mode 100644 index 00000000000..4c67c6674f2 --- /dev/null +++ b/lisp/cedet/semantic/dep.el @@ -0,0 +1,228 @@ +;;; dep.el --- Methods for tracking dependencies (include files) + +;;; Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc. + +;; Author: Eric M. Ludlam +;; Keywords: syntax + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; Include tags (dependencies for a given source file) usually have +;; some short name. The target file that it is dependent on is +;; generally found on some sort of path controlled by the compiler or +;; project. +;; +;; EDE or even ECB can control our project dependencies, and help us +;; find file within the setting of a given project. For system +;; dependencies, we need to depend on user supplied lists, which can +;; manifest themselves in the form of system datatabases (from +;; semanticdb.) +;; +;; Provide ways to track these different files here. + +(require 'semantic/tag) + +;;; Code: + +(defvar semantic-dependency-include-path nil + "Defines the include path used when searching for files. +This should be a list of directories to search which is specific +to the file being included. + +If `semantic-dependency-tag-file' is overridden for a given +language, this path is most likely ignored. + +The above function, reguardless of being overriden, caches the +located dependency file location in the tag property +`dependency-file'. If you override this function, you do not +need to implement your own cache. Each time the buffer is fully +reparsed, the cache will be reset. + +TODO: use ffap.el to locate such items? + +NOTE: Obsolete this, or use as special user") +(make-variable-buffer-local `semantic-dependency-include-path) + +(defvar semantic-dependency-system-include-path nil + "Defines the system include path. +This should be set with either `defvar-mode-local', or with +`semantic-add-system-include'. + +For mode authors, use +`defcustom-mode-local-semantic-dependency-system-include-path' +to create a mode-specific variable to control this. + +When searching for a file associated with a name found in an tag of +class include, this path will be inspected for includes of type +`system'. Some include tags are agnostic to this setting and will +check both the project and system directories.") +(make-variable-buffer-local `semantic-dependency-system-include-path) + +(defmacro defcustom-mode-local-semantic-dependency-system-include-path + (mode name value &optional docstring) + "Create a mode-local value of the system-dependency include path. +MODE is the `major-mode' this name/value pairs is for. +NAME is the name of the customizable value users will use. +VALUE is the path (a list of strings) to add. +DOCSTRING is a documentation string applied to the variable NAME +users will customize. + +Creates a customizable variable users can customize that will +keep semantic data structures up to date." + `(progn + ;; Create a variable users can customize. + (defcustom ,name ,value + ,docstring + :group (quote ,(intern (car (split-string (symbol-name mode) "-")))) + :group 'semantic + :type '(repeat (directory :tag "Directory")) + :set (lambda (sym val) + (set-default sym val) + (setq-mode-local ,mode + semantic-dependency-system-include-path + val) + (when (fboundp + 'semantic-decoration-unparsed-include-do-reset) + (mode-local-map-mode-buffers + 'semantic-decoration-unparsed-include-do-reset + (quote ,mode)))) + ) + ;; Set the variable to the default value. + (defvar-mode-local ,mode semantic-dependency-system-include-path + ,name + "System path to search for include files.") + ;; Bind NAME onto our variable so tools can customize it + ;; without knowing about it. + (put 'semantic-dependency-system-include-path + (quote ,mode) (quote ,name)) + )) + +;;; PATH MANAGEMENT +;; +;; Some fcns to manage paths for a give mode. +(defun semantic-add-system-include (dir &optional mode) + "Add a system include DIR to path for MODE. +Modifies a mode-local version of `semantic-dependency-system-include-path'. + +Changes made by this function are not persistent." + (interactive "DNew Include Directory: ") + (if (not mode) (setq mode major-mode)) + (let ((dirtmp (file-name-as-directory dir)) + (value + (mode-local-value mode 'semantic-dependency-system-include-path)) + ) + (add-to-list 'value dirtmp t) + (eval `(setq-mode-local ,mode + semantic-dependency-system-include-path value)) + )) + +(defun semantic-remove-system-include (dir &optional mode) + "Add a system include DIR to path for MODE. +Modifies a mode-local version of`semantic-dependency-system-include-path'. + +Changes made by this function are not persistent." + (interactive (list + (completing-read + "Include Directory to Remove: " + semantic-dependency-system-include-path)) + ) + (if (not mode) (setq mode major-mode)) + (let ((dirtmp (file-name-as-directory dir)) + (value + (mode-local-value mode 'semantic-dependency-system-include-path)) + ) + (setq value (delete dirtmp value)) + (eval `(setq-mode-local ,mode semantic-dependency-system-include-path + value)) + )) + +(defun semantic-reset-system-include (&optional mode) + "Reset the system include list to empty for MODE. +Modifies a mode-local version of +`semantic-dependency-system-include-path'." + (interactive) + (if (not mode) (setq mode major-mode)) + (eval `(setq-mode-local ,mode semantic-dependency-system-include-path + nil)) + ) + +(defun semantic-customize-system-include-path (&optional mode) + "Customize the include path for this `major-mode'. +To create a customizable include path for a major MODE, use the +macro `defcustom-mode-local-semantic-dependency-system-include-path'." + (interactive) + (let ((ips (get 'semantic-dependency-system-include-path + (or mode major-mode)))) + ;; Do we have one? + (when (not ips) + (error "There is no customizable includepath variable for %s" + (or mode major-mode))) + ;; Customize it. + (customize-variable ips))) + +;;; PATH SEARCH +;; +;; methods for finding files on a provided path. +(if (fboundp 'locate-file) + (defsubst semantic--dependency-find-file-on-path (file path) + "Return an expanded file name for FILE on PATH." + (locate-file file path)) + + ;; Else, older version of Emacs. + + (defsubst semantic--dependency-find-file-on-path (file path) + "Return an expanded file name for FILE on PATH." + (let ((p path) + (found nil)) + (while (and p (not found)) + (let ((f (expand-file-name file (car p)))) + (if (file-exists-p f) + (setq found f))) + (setq p (cdr p))) + found)) + + ) + +(defun semantic-dependency-find-file-on-path (file systemp &optional mode) + "Return an expanded file name for FILE on available paths. +If SYSTEMP is true, then only search system paths. +If optional argument MODE is non-nil, then derive paths from the +provided mode, not from the current major mode." + (if (not mode) (setq mode major-mode)) + (let ((sysp (mode-local-value + mode 'semantic-dependency-system-include-path)) + (edesys (when (and (featurep 'ede) ede-minor-mode + ede-object) + (ede-system-include-path ede-object))) + (locp (mode-local-value + mode 'semantic-dependency-include-path)) + (found nil)) + (when (file-exists-p file) + (setq found file)) + (when (and (not found) (not systemp)) + (setq found (semantic--dependency-find-file-on-path file locp))) + (when (and (not found) edesys) + (setq found (semantic--dependency-find-file-on-path file edesys))) + (when (not found) + (setq found (semantic--dependency-find-file-on-path file sysp))) + (if found (expand-file-name found)))) + + +(provide 'semantic/dep) + +;;; semantic-dep.el ends here diff --git a/lisp/cedet/semantic/ia.el b/lisp/cedet/semantic/ia.el new file mode 100644 index 00000000000..eadf89439ab --- /dev/null +++ b/lisp/cedet/semantic/ia.el @@ -0,0 +1,439 @@ +;;; ia.el --- Interactive Analysis functions + +;;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, +;;; 2008, 2009 Free Software Foundation, Inc. + +;; Author: Eric M. Ludlam +;; Keywords: syntax + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; Interactive access to `semantic-analyze'. +;; +;; These routines are fairly simple, and show how to use the Semantic +;; analyzer to provide things such as completion lists, summaries, +;; locations, or documentation. +;; + +;;; TODO +;; +;; fast-jump. For a virtual method, offer some of the possible +;; implementations in various sub-classes. + +(require 'senator) +(require 'semantic/analyze) +(require 'pulse) +(eval-when-compile + (require 'semantic/analyze) + (require 'semantic/analyze/refs)) + +;;; Code: + +;;; COMPLETION +;; +;; This set of routines provides some simplisting completion +;; functions. + +(defcustom semantic-ia-completion-format-tag-function + 'semantic-prototype-nonterminal + "*Function used to convert a tag to a string during completion." + :group 'semantic + :type semantic-format-tag-custom-list) + +(defvar semantic-ia-cache nil + "Cache of the last completion request. +Of the form ( POINT . COMPLETIONS ) where POINT is a location in the +buffer where the completion was requested. COMPLETONS is the list +of semantic tag names that provide logical completions from that +location.") +(make-variable-buffer-local 'semantic-ia-cache) + +(defun semantic-ia-get-completions (context point) + "Fetch the completion of CONTEXT at POINT. +Supports caching." + ;; Cache the current set of symbols so that we can get at + ;; them quickly the second time someone presses the + ;; complete button. + (let ((symbols + (if (and semantic-ia-cache + (= point (car semantic-ia-cache))) + (cdr semantic-ia-cache) + (semantic-analyze-possible-completions context)))) + ;; Set the cache + (setq semantic-ia-cache (cons point symbols)) + symbols)) + +(defun semantic-ia-complete-symbol (point) + "Complete the current symbol at POINT. +Completion options are calculated with `semantic-analyze-possible-completions'." + (interactive "d") + ;; Calculating completions is a two step process. + ;; + ;; The first analyzer the current context, which finds tags + ;; for all the stuff that may be references by the code around + ;; POINT. + ;; + ;; The second step derives completions from that context. + (let* ((a (semantic-analyze-current-context point)) + (syms (semantic-ia-get-completions a point)) + (pre (car (reverse (oref a prefix)))) + ) + ;; If PRE was actually an already completed symbol, it doesn't + ;; come in as a string, but as a tag instead. + (if (semantic-tag-p pre) + ;; We will try completions on it anyway. + (setq pre (semantic-tag-name pre))) + ;; Complete this symbol. + (if (null syms) + (progn + ;(message "No smart completions found. Trying senator-complete-symbol.") + (if (semantic-analyze-context-p a) + ;; This is a clever hack. If we were unable to find any + ;; smart completions, lets divert to how senator derives + ;; completions. + ;; + ;; This is a way of making this fcn more useful since the + ;; smart completion engine sometimes failes. + (senator-complete-symbol) + )) + ;; Use try completion to seek a common substring. + (let ((tc (try-completion (or pre "") syms))) + (if (and (stringp tc) (not (string= tc (or pre "")))) + (let ((tok (semantic-find-first-tag-by-name + tc syms))) + ;; Delete what came before... + (when (and (car (oref a bounds)) (cdr (oref a bounds))) + (delete-region (car (oref a bounds)) + (cdr (oref a bounds))) + (goto-char (car (oref a bounds)))) + ;; We have some new text. Stick it in. + (if tok + (semantic-ia-insert-tag tok) + (insert tc))) + ;; We don't have new text. Show all completions. + (when (cdr (oref a bounds)) + (goto-char (cdr (oref a bounds)))) + (with-output-to-temp-buffer "*Completions*" + (display-completion-list + (mapcar semantic-ia-completion-format-tag-function syms)) + )))))) + +(defcustom semantic-ia-completion-menu-format-tag-function + 'semantic-uml-concise-prototype-nonterminal + "*Function used to convert a tag to a string during completion." + :group 'semantic + :type semantic-format-tag-custom-list) + +(defun semantic-ia-complete-symbol-menu (point) + "Complete the current symbol via a menu based at POINT. +Completion options are calculated with `semantic-analyze-possible-completions'." + (interactive "d") + (let* ((a (semantic-analyze-current-context point)) + (syms (semantic-ia-get-completions a point)) + ) + ;; Complete this symbol. + (if (not syms) + (progn + (message "No smart completions found. Trying Senator.") + (when (semantic-analyze-context-p a) + ;; This is a quick way of getting a nice completion list + ;; in the menu if the regular context mechanism fails. + (senator-completion-menu-popup))) + + (let* ((menu + (mapcar + (lambda (tag) + (cons + (funcall semantic-ia-completion-menu-format-tag-function tag) + (vector tag))) + syms)) + (ans + (imenu--mouse-menu + ;; XEmacs needs that the menu has at least 2 items. So, + ;; include a nil item that will be ignored by imenu. + (cons nil menu) + (senator-completion-menu-point-as-event) + "Completions"))) + (when ans + (if (not (semantic-tag-p ans)) + (setq ans (aref (cdr ans) 0))) + (delete-region (car (oref a bounds)) (cdr (oref a bounds))) + (semantic-ia-insert-tag ans)) + )))) + +;;; COMPLETION HELPER +;; +;; This overload function handles inserting a tag +;; into a buffer for these local completion routines. +;; +;; By creating the functions as overloadable, it can be +;; customized. For example, the default will put a paren "(" +;; character after function names. For Lisp, it might check +;; to put a "(" in front of a function name. + +(define-overloadable-function semantic-ia-insert-tag (tag) + "Insert TAG into the current buffer based on completion.") + +(defun semantic-ia-insert-tag-default (tag) + "Insert TAG into the current buffer based on completion." + (insert (semantic-tag-name tag)) + (let ((tt (semantic-tag-class tag))) + (cond ((eq tt 'function) + (insert "(")) + (t nil)))) + +;;; Completions Tip +;; +;; This functions shows how to get the list of completions, +;; to place in a tooltip. It doesn't actually do any completion. + +(defun semantic-ia-complete-tip (point) + "Pop up a tooltip for completion at POINT." + (interactive "d") + (let* ((a (semantic-analyze-current-context point)) + (syms (semantic-ia-get-completions a point)) + (x (mod (- (current-column) (window-hscroll)) + (window-width))) + (y (save-excursion + (save-restriction + (widen) + (narrow-to-region (window-start) (point)) + (goto-char (point-min)) + (1+ (vertical-motion (buffer-size)))))) + (str (mapconcat #'semantic-tag-name + syms + "\n")) + ) + (cond ((fboundp 'x-show-tip) + (x-show-tip str + (selected-frame) + nil + nil + x y) + ) + (t (message str)) + ))) + +;;; Summary +;; +;; Like idle-summary-mode, this shows how to get something to +;; show a summary on. + +(defun semantic-ia-show-summary (point) + "Display a summary for the symbol under POINT." + (interactive "P") + (let* ((ctxt (semantic-analyze-current-context point)) + (pf (when ctxt + ;; The CTXT is an EIEIO object. The below + ;; method will attempt to pick the most interesting + ;; tag associated with the current context. + (semantic-analyze-interesting-tag ctxt))) + ) + (when pf + (message "%s" (semantic-format-tag-summarize pf nil t))))) + +;;; FAST Jump +;; +;; Jump to a destination based on the local context. +;; +;; This shows how to use the analyzer context, and the +;; analyer references objects to choose a good destination. + +(defun semantic-ia--fast-jump-helper (dest) + "Jump to DEST, a Semantic tag. +This helper manages the mark, buffer switching, and pulsing." + ;; We have a tag, but in C++, we usually get a prototype instead + ;; because of header files. Lets try to find the actual + ;; implementaion instead. + (when (semantic-tag-prototype-p dest) + (let* ((refs (semantic-analyze-tag-references dest)) + (impl (semantic-analyze-refs-impl refs t)) + ) + (when impl (setq dest (car impl))))) + + ;; Make sure we have a place to go... + (if (not (and (or (semantic-tag-with-position-p dest) + (semantic-tag-get-attribute dest :line)) + (semantic-tag-file-name dest))) + (error "Tag %s has no buffer information" + (semantic-format-tag-name dest))) + + ;; Once we have the tag, we can jump to it. Here + ;; are the key bits to the jump: + + ;; 1) Push the mark, so you can pop global mark back, or + ;; use semantic-mru-bookmark mode to do so. + (push-mark) + (when (fboundp 'push-tag-mark) + (push-tag-mark)) + ;; 2) Visits the tag. + (semantic-go-to-tag dest) + ;; 3) go-to-tag doesn't switch the buffer in the current window, + ;; so it is like find-file-noselect. Bring it forward. + (switch-to-buffer (current-buffer)) + ;; 4) Fancy pulsing. + (pulse-momentary-highlight-one-line (point)) + ) + +(defun semantic-ia-fast-jump (point) + "Jump to the tag referred to by the code at POINT. +Uses `semantic-analyze-current-context' output to identify an accurate +origin of the code at point." + (interactive "d") + (let* ((ctxt (semantic-analyze-current-context point)) + (pf (and ctxt (reverse (oref ctxt prefix)))) + ;; In the analyzer context, the PREFIX is the list of items + ;; that makes up the code context at point. Thus the c++ code + ;; this.that().theothe + ;; would make a list: + ;; ( ("this" variable ..) ("that" function ...) "theothe") + ;; Where the first two elements are the semantic tags of the prefix. + ;; + ;; PF is the reverse of this list. If the first item is a string, + ;; then it is an incomplete symbol, thus we pick the second. + ;; The second cannot be a string, as that would have been an error. + (first (car pf)) + (second (nth 1 pf)) + ) + (cond + ((semantic-tag-p first) + ;; We have a match. Just go there. + (semantic-ia--fast-jump-helper first)) + + ((semantic-tag-p second) + ;; Because FIRST failed, we should visit our second tag. + ;; HOWEVER, the tag we actually want that was only an unfound + ;; string may be related to some take in the datatype that belongs + ;; to SECOND. Thus, instead of visiting second directly, we + ;; can offer to find the type of SECOND, and go there. + (let ((secondclass (car (reverse (oref ctxt prefixtypes))))) + (cond + ((and (semantic-tag-with-position-p secondclass) + (y-or-n-p (format "Could not find `%s'. Jump to %s? " + first (semantic-tag-name secondclass)))) + (semantic-ia--fast-jump-helper secondclass) + ) + ;; If we missed out on the class of the second item, then + ;; just visit SECOND. + ((and (semantic-tag-p second) + (y-or-n-p (format "Could not find `%s'. Jump to %s? " + first (semantic-tag-name second)))) + (semantic-ia--fast-jump-helper second) + )))) + + ((semantic-tag-of-class-p (semantic-current-tag) 'include) + ;; Just borrow this cool fcn. + (semantic-decoration-include-visit) + ) + + (t + (error "Could not find suitable jump point for %s" + first)) + ))) + +(defun semantic-ia-fast-mouse-jump (evt) + "Jump to the tag referred to by the point clicked on. +See `semantic-ia-fast-jump' for details on how it works. + This command is meant to be bound to a mouse event." + (interactive "e") + (semantic-ia-fast-jump + (save-excursion + (posn-set-point (event-end evt)) + (point)))) + +;;; DOC/DESCRIBE +;; +;; These routines show how to get additional information about a tag +;; for purposes of describing or showing documentation about them. +(defun semantic-ia-show-doc (point) + "Display the code-level documentation for the symbol at POINT." + (interactive "d") + (let* ((ctxt (semantic-analyze-current-context point)) + (pf (reverse (oref ctxt prefix))) + ) + ;; If PF, the prefix is non-nil, then the last element is either + ;; a string (incomplete type), or a semantic TAG. If it is a TAG + ;; then we should be able to find DOC for it. + (cond + ((stringp (car pf)) + (message "Incomplete symbol name.")) + ((semantic-tag-p (car pf)) + ;; The `semantic-documentation-for-tag' fcn is language + ;; specific. If it doesn't return what you expect, you may + ;; need to implement something for your language. + ;; + ;; The default tries to find a comment in front of the tag + ;; and then strings off comment prefixes. + (let ((doc (semantic-documentation-for-tag (car pf)))) + (with-output-to-temp-buffer "*TAG DOCUMENTATION*" + (princ "Tag: ") + (princ (semantic-format-tag-prototype (car pf))) + (princ "\n") + (princ "\n") + (princ "Snarfed Documentation: ") + (princ "\n") + (princ "\n") + (if doc + (princ doc) + (princ " Documentation unavailable.")) + ))) + (t + (message "Unknown tag."))) + )) + +(defun semantic-ia-describe-class (typename) + "Display all known parts for the datatype TYPENAME. +If the type in question is a class, all methods and other accessible +parts of the parent classes are displayed." + ;; @todo - use a fancy completing reader. + (interactive "sType Name: ") + + ;; When looking for a tag of any name there are a couple ways to do + ;; it. The simple `semanticdb-find-tag-by-...' are simple, and + ;; you need to pass it the exact name you want. + ;; + ;; The analyzer function `semantic-analyze-tag-name' will take + ;; more complex names, such as the cpp symbol foo::bar::baz, + ;; and break it up, and dive through the namespaces. + (let ((class (semantic-analyze-find-tag typename))) + + (when (not (semantic-tag-p class)) + (error "Cannot find class %s" class)) + (with-output-to-temp-buffer "*TAG DOCUMENTATION*" + ;; There are many semantic-format-tag-* fcns. + ;; The summarize routine is a fairly generic one. + (princ (semantic-format-tag-summarize class)) + (princ "\n") + (princ " Type Members:\n") + ;; The type tag contains all the parts of the type. + ;; In complex languages with inheritance, not all the + ;; parts are in the tag. This analyzer fcn will traverse + ;; the inheritance tree, and find all the pieces that + ;; are inherited. + (let ((parts (semantic-analyze-scoped-type-parts class))) + (while parts + (princ " ") + (princ (semantic-format-tag-summarize (car parts))) + (princ "\n") + (setq parts (cdr parts))) + ) + ))) + +(provide 'semantic/ia) + +;;; semantic-ia.el ends here diff --git a/lisp/cedet/semantic/tag-file.el b/lisp/cedet/semantic/tag-file.el new file mode 100644 index 00000000000..4187d3c0302 --- /dev/null +++ b/lisp/cedet/semantic/tag-file.el @@ -0,0 +1,202 @@ +;;; tag-file.el --- Routines that find files based on tags. + +;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, +;;; 2008, 2009 Free Software Foundation, Inc. + +;; Author: Eric M. Ludlam +;; Keywords: syntax + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; A tag, by itself, can have representations in several files. +;; These routines will find those files. + +(require 'semantic/tag) + +;;; Code: + +;;; Location a TAG came from. +;; +(define-overloadable-function semantic-go-to-tag (tag &optional parent) + "Go to the location of TAG. +TAG may be a stripped element, in which case PARENT specifies a +parent tag that has position information. +PARENT can also be a `semanticdb-table' object." + (:override + (cond ((semantic-tag-in-buffer-p tag) + ;; We have a linked tag, go to that buffer. + (set-buffer (semantic-tag-buffer tag))) + ((semantic-tag-file-name tag) + ;; If it didn't have a buffer, but does have a file + ;; name, then we need to get to that file so the tag + ;; location is made accurate. + (set-buffer (find-file-noselect (semantic-tag-file-name tag)))) + ((and parent (semantic-tag-p parent) (semantic-tag-in-buffer-p parent)) + ;; The tag had nothing useful, but we have a parent with + ;; a buffer, then go there. + (set-buffer (semantic-tag-buffer parent))) + ((and parent (semantic-tag-p parent) (semantic-tag-file-name parent)) + ;; Tag had nothing, and the parent only has a file-name, then + ;; find that file, and switch to that buffer. + (set-buffer (find-file-noselect (semantic-tag-file-name parent)))) + ((and parent (semanticdb-table-child-p parent)) + (set-buffer (semanticdb-get-buffer parent))) + (t + ;; Well, just assume things are in the current buffer. + nil + )) + ;; We should be in the correct buffer now, try and figure out + ;; where the tag is. + (cond ((semantic-tag-with-position-p tag) + ;; If it's a number, go there + (goto-char (semantic-tag-start tag))) + ((semantic-tag-with-position-p parent) + ;; Otherwise, it's a trimmed vector, such as a parameter, + ;; or a structure part. If there is a parent, we can use it + ;; as a bounds for searching. + (goto-char (semantic-tag-start parent)) + ;; Here we make an assumption that the text returned by + ;; the parser and concocted by us actually exists + ;; in the buffer. + (re-search-forward (semantic-tag-name tag) + (semantic-tag-end parent) + t)) + ((semantic-tag-get-attribute tag :line) + ;; The tag has a line number in it. Go there. + (goto-line (semantic-tag-get-attribute tag :line))) + ((and (semantic-tag-p parent) (semantic-tag-get-attribute parent :line)) + ;; The tag has a line number in it. Go there. + (goto-line (semantic-tag-get-attribute parent :line)) + (re-search-forward (semantic-tag-name tag) nil t) + ) + (t + ;; Take a guess that the tag has a unique name, and just + ;; search for it from the beginning of the buffer. + (goto-char (point-min)) + (re-search-forward (semantic-tag-name tag) nil t))) + ) + ) + +(make-obsolete-overload 'semantic-find-nonterminal + 'semantic-go-to-tag) + +;;; Dependencies +;; +;; A tag which is of type 'include specifies a dependency. +;; Dependencies usually represent a file of some sort. +;; Find the file described by a dependency. + +(define-overloadable-function semantic-dependency-tag-file (&optional tag) + "Find the filename represented from TAG. +Depends on `semantic-dependency-include-path' for searching. Always searches +`.' first, then searches additional paths." + (or tag (setq tag (car (semantic-find-tag-by-overlay nil)))) + (unless (semantic-tag-of-class-p tag 'include) + (signal 'wrong-type-argument (list tag 'include))) + (save-excursion + (let ((result nil) + (default-directory default-directory) + (edefind nil) + (tag-fname nil)) + (cond ((semantic-tag-in-buffer-p tag) + ;; If the tag has an overlay and buffer associated with it, + ;; switch to that buffer so that we get the right override metohds. + (set-buffer (semantic-tag-buffer tag))) + ((semantic-tag-file-name tag) + ;; If it didn't have a buffer, but does have a file + ;; name, then we need to get to that file so the tag + ;; location is made accurate. + ;;(set-buffer (find-file-noselect (semantic-tag-file-name tag))) + ;; + ;; 2/3/08 + ;; The above causes unnecessary buffer loads all over the place. Ick! + ;; All we really need is for 'default-directory' to be set correctly. + (setq default-directory (file-name-directory (semantic-tag-file-name tag))) + )) + ;; Setup the filename represented by this include + (setq tag-fname (semantic-tag-include-filename tag)) + + ;; First, see if this file exists in the current EDE project + (if (and (fboundp 'ede-expand-filename) ede-minor-mode + (setq edefind + (condition-case nil + (let ((proj (ede-toplevel))) + (when proj + (ede-expand-filename proj tag-fname))) + (error nil)))) + (setq result edefind)) + (if (not result) + (setq result + ;; I don't have a plan for refreshing tags with a dependency + ;; stuck on them somehow. I'm thinking that putting a cache + ;; onto the dependancy finding with a hash table might be best. + ;;(if (semantic--tag-get-property tag 'dependency-file) + ;; (semantic--tag-get-property tag 'dependency-file) + (:override + (save-excursion + (semantic-dependency-find-file-on-path + tag-fname (semantic-tag-include-system-p tag)))) + ;; ) + )) + (if (stringp result) + (progn + (semantic--tag-put-property tag 'dependency-file result) + result) + ;; @todo: Do something to make this get flushed w/ + ;; when the path is changed. + ;; @undo: Just eliminate + ;; (semantic--tag-put-property tag 'dependency-file 'none) + nil) + ))) + +(make-obsolete-overload 'semantic-find-dependency + 'semantic-dependency-tag-file) + +;;; PROTOTYPE FILE +;; +;; In C, a function in the .c file often has a representation in a +;; corresponding .h file. This routine attempts to find the +;; prototype file a given source file would be associated with. +;; This can be used by prototype manager programs. +(define-overloadable-function semantic-prototype-file (buffer) + "Return a file in which prototypes belonging to BUFFER should be placed. +Default behavior (if not overridden) looks for a token specifying the +prototype file, or the existence of an EDE variable indicating which +file prototypes belong in." + (:override + ;; Perform some default behaviors + (if (and (fboundp 'ede-header-file) ede-minor-mode) + (save-excursion + (set-buffer buffer) + (ede-header-file)) + ;; No EDE options for a quick answer. Search. + (save-excursion + (set-buffer buffer) + (if (re-search-forward "::Header:: \\([a-zA-Z0-9.]+\\)" nil t) + (match-string 1)))))) + +(semantic-alias-obsolete 'semantic-find-nonterminal + 'semantic-go-to-tag) + +(semantic-alias-obsolete 'semantic-find-dependency + 'semantic-dependency-tag-file) + + +(provide 'semantic/tag-file) + +;;; semantic-tag-file.el ends here diff --git a/lisp/cedet/semantic/tag-ls.el b/lisp/cedet/semantic/tag-ls.el new file mode 100644 index 00000000000..634c41cf093 --- /dev/null +++ b/lisp/cedet/semantic/tag-ls.el @@ -0,0 +1,276 @@ +;;; tag-ls.el --- Language Specific override functions for tags + +;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007, 2008 +;;; Free Software Foundation, Inc. + +;; Author: Eric M. Ludlam + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see . + +;;; Commentary: +;; +;; There are some features of tags that are too langauge dependent to +;; put in the core `semantic-tag' functionality. For instance, the +;; protection of a tag (as specified by UML) could be almost anything. +;; In Java, it is a type specifier. In C, there is a label. This +;; informatin can be derived, and thus should not be stored in the tag +;; itself. These are the functions that languages can use to derive +;; the information. + +(require 'semantic/tag) + +;;; Code: + +;;; UML features: +;; +;; UML can represent several types of features of a tag +;; such as the `protection' of a symbol, or if it is abstract, +;; leaf, etc. Learn about UML to catch onto the lingo. + +(define-overloadable-function semantic-tag-calculate-parent (tag) + "Attempt to calculate the parent of TAG. +The default behavior (if not overriden with `tag-calculate-parent') +is to search a buffer found with TAG, and if externally defined, +search locally, then semanticdb for that tag (when enabled.)") + +(defun semantic-tag-calculate-parent-default (tag) + "Attempt to calculate the parent of TAG." + (when (semantic-tag-in-buffer-p tag) + (save-excursion + (set-buffer (semantic-tag-buffer tag)) + (save-excursion + (goto-char (semantic-tag-start tag)) + (semantic-current-tag-parent)) + ))) + +(define-overloadable-function semantic-tag-protection (tag &optional parent) + "Return protection information about TAG with optional PARENT. +This function returns on of the following symbols: + nil - No special protection. Language dependent. + 'public - Anyone can access this TAG. + 'private - Only methods in the local scope can access TAG. + 'protected - Like private for outside scopes, like public for child + classes. +Some languages may choose to provide additional return symbols specific +to themselves. Use of this function should allow for this. + +The default behavior (if not overridden with `tag-protection' +is to return a symbol based on type modifiers." + (and (not parent) + (semantic-tag-overlay tag) + (semantic-tag-in-buffer-p tag) + (setq parent (semantic-tag-calculate-parent tag))) + (:override)) + +(make-obsolete-overload 'semantic-nonterminal-protection + 'semantic-tag-protection) + +(defun semantic-tag-protection-default (tag &optional parent) + "Return the protection of TAG as a child of PARENT default action. +See `semantic-tag-protection'." + (let ((mods (semantic-tag-modifiers tag)) + (prot nil)) + (while (and (not prot) mods) + (if (stringp (car mods)) + (let ((s (car mods))) + (setq prot + ;; A few silly defaults to get things started. + (cond ((or (string= s "public") + (string= s "extern") + (string= s "export")) + 'public) + ((string= s "private") + 'private) + ((string= s "protected") + 'protected))))) + (setq mods (cdr mods))) + prot)) + +(defun semantic-tag-protected-p (tag protection &optional parent) + "Non-nil if TAG is is protected. +PROTECTION is a symbol which can be returned by the method +`semantic-tag-protection'. +PARENT is the parent data type which contains TAG. + +For these PROTECTIONs, true is returned if TAG is: +@table @asis +@item nil + Always true +@item private + True if nil. +@item protected + True if private or nil. +@item public + True if private, protected, or nil. +@end table" + (if (null protection) + t + (let ((tagpro (semantic-tag-protection tag parent))) + (or (and (eq protection 'private) + (null tagpro)) + (and (eq protection 'protected) + (or (null tagpro) + (eq tagpro 'private))) + (and (eq protection 'public) + (not (eq tagpro 'public))))) + )) + +(define-overloadable-function semantic-tag-abstract-p (tag &optional parent) + "Return non nil if TAG is abstract. +Optional PARENT is the parent tag of TAG. +In UML, abstract methods and classes have special meaning and behavior +in how methods are overridden. In UML, abstract methods are italicized. + +The default behavior (if not overridden with `tag-abstract-p' +is to return true if `abstract' is in the type modifiers.") + +(make-obsolete-overload 'semantic-nonterminal-abstract + 'semantic-tag-abstract-p) + +(defun semantic-tag-abstract-p-default (tag &optional parent) + "Return non-nil if TAG is abstract as a child of PARENT default action. +See `semantic-tag-abstract-p'." + (let ((mods (semantic-tag-modifiers tag)) + (abs nil)) + (while (and (not abs) mods) + (if (stringp (car mods)) + (setq abs (or (string= (car mods) "abstract") + (string= (car mods) "virtual")))) + (setq mods (cdr mods))) + abs)) + +(define-overloadable-function semantic-tag-leaf-p (tag &optional parent) + "Return non nil if TAG is leaf. +Optional PARENT is the parent tag of TAG. +In UML, leaf methods and classes have special meaning and behavior. + +The default behavior (if not overridden with `tag-leaf-p' +is to return true if `leaf' is in the type modifiers.") + +(make-obsolete-overload 'semantic-nonterminal-leaf + 'semantic-tag-leaf-p) + +(defun semantic-tag-leaf-p-default (tag &optional parent) + "Return non-nil if TAG is leaf as a child of PARENT default action. +See `semantic-tag-leaf-p'." + (let ((mods (semantic-tag-modifiers tag)) + (leaf nil)) + (while (and (not leaf) mods) + (if (stringp (car mods)) + ;; Use java FINAL as example default. There is none + ;; for C/C++ + (setq leaf (string= (car mods) "final"))) + (setq mods (cdr mods))) + leaf)) + +(define-overloadable-function semantic-tag-static-p (tag &optional parent) + "Return non nil if TAG is static. +Optional PARENT is the parent tag of TAG. +In UML, static methods and attributes mean that they are allocated +in the parent class, and are not instance specific. +UML notation specifies that STATIC entries are underlined.") + +(defun semantic-tag-static-p-default (tag &optional parent) + "Return non-nil if TAG is static as a child of PARENT default action. +See `semantic-tag-static-p'." + (let ((mods (semantic-tag-modifiers tag)) + (static nil)) + (while (and (not static) mods) + (if (stringp (car mods)) + (setq static (string= (car mods) "static"))) + (setq mods (cdr mods))) + static)) + +(define-overloadable-function semantic-tag-prototype-p (tag) + "Return non nil if TAG is a prototype. +For some laguages, such as C, a prototype is a declaration of +something without an implementation." + ) + +(defun semantic-tag-prototype-p-default (tag) + "Non-nil if TAG is a prototype." + (let ((p (semantic-tag-get-attribute tag :prototype-flag))) + (cond + ;; Trust the parser author. + (p p) + ;; Empty types might be a prototype. + ;; @todo - make this better. + ((eq (semantic-tag-class tag) 'type) + (not (semantic-tag-type-members tag))) + ;; No other heuristics. + (t nil)) + )) + +;;; FULL NAMES +;; +;; For programmer convenience, a full name is not specified in source +;; code. Instead some abbreviation is made, and the local environment +;; will contain the info needed to determine the full name. + +(define-overloadable-function semantic-tag-full-name (tag &optional stream-or-buffer) + "Return the fully qualified name of TAG in the package hierarchy. +STREAM-OR-BUFFER can be anything convertable by `semantic-something-to-stream', +but must be a toplevel semantic tag stream that contains TAG. +A Package Hierarchy is defined in UML by the way classes and methods +are organized on disk. Some language use this concept such that a +class can be accessed via it's fully qualified name, (such as Java.) +Other languages qualify names within a Namespace (such as C++) which +result in a different package like structure. Languages which do not +override this function with `tag-full-name' will use +`semantic-tag-name'. Override functions only need to handle +STREAM-OR-BUFFER with a tag stream value, or nil." + (let ((stream (semantic-something-to-tag-table + (or stream-or-buffer tag)))) + (:override-with-args (tag stream)))) + +(make-obsolete-overload 'semantic-nonterminal-full-name + 'semantic-tag-full-name) + +(defun semantic-tag-full-name-default (tag stream) + "Default method for `semantic-tag-full-name'. +Return the name of TAG found in the toplevel STREAM." + (semantic-tag-name tag)) + +;;; Compatibility aliases. +;; +(semantic-alias-obsolete 'semantic-nonterminal-protection + 'semantic-tag-protection) +(semantic-alias-obsolete 'semantic-nonterminal-protection-default + 'semantic-tag-protection-default) +(semantic-alias-obsolete 'semantic-nonterminal-abstract + 'semantic-tag-abstract-p) +(semantic-alias-obsolete 'semantic-nonterminal-abstract-default + 'semantic-tag-abstract-p-default) +(semantic-alias-obsolete 'semantic-nonterminal-leaf + 'semantic-tag-leaf-p) +(semantic-alias-obsolete 'semantic-nonterminal-leaf-default + 'semantic-tag-leaf-p-default) +(semantic-alias-obsolete 'semantic-nonterminal-static-default + 'semantic-tag-static-p-default) +(semantic-alias-obsolete 'semantic-nonterminal-full-name + 'semantic-tag-full-name) +(semantic-alias-obsolete 'semantic-nonterminal-full-name-default + 'semantic-tag-full-name-default) + +;; TEMPORARY within betas of CEDET 1.0 +(semantic-alias-obsolete 'semantic-tag-static 'semantic-tag-static-p) +(semantic-alias-obsolete 'semantic-tag-leaf 'semantic-tag-leaf-p) +(semantic-alias-obsolete 'semantic-tag-abstract 'semantic-tag-abstract-p) + + +(provide 'semantic/tag-ls) + +;;; semantic-tag-ls.el ends here