1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
;;; semantic/dep.el --- Methods for tracking dependencies (include files)
;; Copyright (C) 2006-2012 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; 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 <http://www.gnu.org/licenses/>.
;;; 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 databases (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, regardless of being overridden, 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.
;;;###autoload
(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))
))
;;;###autoload
(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))
))
;;;###autoload
(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))
)
;;;###autoload
(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.
(defmacro semantic--dependency-find-file-on-path (file path)
(if (fboundp 'locate-file)
`(locate-file ,file ,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)))
(defvar ede-minor-mode)
(defvar ede-object)
(declare-function ede-system-include-path "ede")
(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
(if (listp ede-object) (car ede-object) 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)
;; Local variables:
;; generated-autoload-file: "loaddefs.el"
;; generated-autoload-load-name: "semantic/dep"
;; End:
;;; semantic/dep.el ends here
|
