|
0
|
1 ;;!emacs
|
|
|
2 ;;
|
|
|
3 ;; FILE: br-c++-ft.el
|
|
|
4 ;; SUMMARY: C++ OO-Browser class and member functions.
|
|
|
5 ;; USAGE: GNU Emacs Lisp Library
|
|
|
6 ;; KEYWORDS: c, oop, tools
|
|
|
7 ;;
|
|
|
8 ;; AUTHOR: Bob Weiner
|
|
|
9 ;; ORG: Motorola Inc.
|
|
|
10 ;;
|
|
|
11 ;; ORIG-DATE: 03-Oct-90
|
|
|
12 ;; LAST-MOD: 5-May-95 at 15:59:53 by Bob Weiner
|
|
|
13 ;;
|
|
|
14 ;; Copyright (C) 1990-1995 Free Software Foundation, Inc.
|
|
|
15 ;; See the file BR-COPY for license information.
|
|
|
16 ;;
|
|
|
17 ;; This file is part of the OO-Browser.
|
|
|
18 ;;
|
|
|
19 ;; DESCRIPTION:
|
|
|
20 ;; DESCRIP-END.
|
|
|
21
|
|
|
22 ;;; ************************************************************************
|
|
|
23 ;;; Other required Elisp libraries
|
|
|
24 ;;; ************************************************************************
|
|
|
25
|
|
|
26 (require 'br-c++)
|
|
|
27
|
|
|
28 ;;; ************************************************************************
|
|
|
29 ;;; Public variables
|
|
|
30 ;;; ************************************************************************
|
|
|
31
|
|
|
32 (defvar c++-cpp-include-dirs '("/usr/include/")
|
|
|
33 "*Ordered list of include directories by default searched by C preprocessor.
|
|
|
34 Each directory must end with a directory separator. See also
|
|
|
35 'c++-include-dirs'.")
|
|
|
36
|
|
|
37 (defvar c++-include-dirs nil
|
|
|
38 "*Ordered list of directories to search for C++ include files.
|
|
|
39 Each directory must end with a directory separator. Directories normally
|
|
|
40 searched by the C++ pre-processor should be set instead in
|
|
|
41 'c++-cpp-include-dirs'.")
|
|
|
42
|
|
|
43 ;; Modified on 3/28/95 to handle C++ names with multiple template
|
|
|
44 ;; parameters, e.g. class<T1,T2,T3>. Unfortunately for our pattern matcher,
|
|
|
45 ;; we also have to allow spaces within the template parameters section. We
|
|
|
46 ;; consciously do not allow newlines within the parameters section to avoid
|
|
|
47 ;; grabbing too much of the expression that follows.
|
|
|
48 (defconst c++-return-type-identifier
|
|
|
49 (concat "[\[<a-zA-Z]"
|
|
|
50 "[]" c++-template-identifier-chars "]*"
|
|
|
51 "\\(::[]" c++-template-identifier-chars "]+\\)?"
|
|
|
52 "[ \t\n\^M]*<[" c++-return-type-chars " ,]+>[ \t\n\^M]*[*&]*"
|
|
|
53 "\\|[\[<a-zA-Z][]" c++-return-type-chars "]*"
|
|
|
54 "\\(::[\[<a-zA-Z][]" c++-return-type-chars "]+\\)?"
|
|
|
55 "[ \t\n\^M]*[*&]*"))
|
|
|
56
|
|
|
57 (defconst c++-type-identifier
|
|
|
58 (concat "\\(::\\|[\[<a-zA-Z][]" c++-template-identifier-chars "]*"
|
|
|
59 "[ \t\n\^M]*<[^>;{}]+>[ \t\n\^M]*[*&]*::"
|
|
|
60 "\\|[\[<a-zA-Z][]" c++-identifier-chars "]*[ \t\n\^M]*[*&]*::\\)"))
|
|
|
61
|
|
|
62 (defconst c++-type-tag-separator "@"
|
|
|
63 "String that separates a tag's type from its normalized definition form.
|
|
|
64 This should be a single character which is unchanged when quoted for use as a
|
|
|
65 literal in a regular expression.")
|
|
|
66
|
|
|
67 (defconst c++-tag-fields-regexp
|
|
|
68 ;; The \\\\? below is necessary because we sometimes use this expression to
|
|
|
69 ;; test against a string that has ben regexp-quoted and some of the
|
|
|
70 ;; characters in br-feature-type-regexp will then be preceded by \\.
|
|
|
71 (format "\\`\\([^%s \n]+\\)%s\\\\?\\(%s \\)\\([^%s\n]+\\)%s"
|
|
|
72 c++-type-tag-separator c++-type-tag-separator br-feature-type-regexp
|
|
|
73 c++-type-tag-separator c++-type-tag-separator)
|
|
|
74 "Regexp matching the fields of a C++ feature tag line.
|
|
|
75 Group 1 is the class of the feature. Group 2 is the prefix preceding the
|
|
|
76 feature when displayed within a listing buffer. Group 3 is the feature name.
|
|
|
77 The feature definition signature begins at the end of the regexp match,
|
|
|
78 i.e. (match-end 0), and goes to the end of the string or line.")
|
|
|
79
|
|
|
80 ;;; ************************************************************************
|
|
|
81 ;;; Public functions
|
|
|
82 ;;; ************************************************************************
|
|
|
83
|
|
|
84 (defun c++-add-default-classes ()
|
|
|
85 ;; Add to 'system' class table.
|
|
|
86 (if br-c-tags-flag
|
|
|
87 (c-add-default-classes)
|
|
|
88 ;; Even if this flag is nil, the Environment still contains C function
|
|
|
89 ;; tag entries, so add this default class.
|
|
|
90 (br-add-class "[function]" br-null-path nil)))
|
|
|
91
|
|
|
92 (defun c++-member-p ()
|
|
|
93 "Prints whether entity at point is a C++ member definition or declaration."
|
|
|
94 (interactive)
|
|
|
95 (let ((name))
|
|
|
96 (save-excursion
|
|
|
97 (message
|
|
|
98 (concat
|
|
|
99 "Is " (if (c++-feature-def-p)
|
|
|
100 (progn (setq name
|
|
|
101 (buffer-substring (match-beginning
|
|
|
102 c++-feature-name-grpn)
|
|
|
103 (match-end
|
|
|
104 c++-feature-name-grpn)))
|
|
|
105 "")
|
|
|
106 "not ")
|
|
|
107 "a def. "
|
|
|
108 "Is " (if (and (c++-skip-to-statement) (c++-feature-decl))
|
|
|
109 (progn (setq name
|
|
|
110 (buffer-substring (match-beginning
|
|
|
111 c++-feature-name-grpn)
|
|
|
112 (match-end
|
|
|
113 c++-feature-name-grpn)))
|
|
|
114 "")
|
|
|
115 "not ")
|
|
|
116 "a member decl. "
|
|
|
117 (if name (concat " Name = " name)))))))
|
|
|
118
|
|
|
119 (defun c++-feature-implementors (name)
|
|
|
120 "Return unsorted list of C++ feature tags which implement feature NAME.
|
|
|
121 This includes classes which define the interface for NAME as a pure virtual
|
|
|
122 function."
|
|
|
123 (c++-feature-matches (concat "^" (regexp-quote name) "$")))
|
|
|
124
|
|
|
125 (defun c++-feature-locate-p (feature-tag &optional regexp-flag)
|
|
|
126 "Leaves point at the start of FEATURE-TAG's definition in the current buffer.
|
|
|
127 Assumes caller has moved point to the beginning of the buffer or to the point
|
|
|
128 of desired search start.
|
|
|
129 Optional REGEXP-FLAG means FEATURE-TAG is a regular expression."
|
|
|
130 ;; Match to function definitions, not declarations, except for pure virtual
|
|
|
131 ;; functions and friends which are declared, not defined, and so end with a
|
|
|
132 ;; ';'.
|
|
|
133 ;;
|
|
|
134 ;; First move to the proper class implementation if feature-tag does not
|
|
|
135 ;; include a <class>:: part and this is not a [default-class], so that if
|
|
|
136 ;; two classes in the same file have the same feature signature, we still
|
|
|
137 ;; end up at the right one.
|
|
|
138 (if (string-match c++-tag-fields-regexp feature-tag)
|
|
|
139 (let ((class (substring feature-tag (match-beginning 1) (match-end 1))))
|
|
|
140 (setq feature-tag (substring feature-tag (match-end 0)))
|
|
|
141 (if regexp-flag
|
|
|
142 (if (not (string-match "\\`\\\\\\[\\|::" feature-tag))
|
|
|
143 (re-search-forward (c++-class-definition-regexp class t)
|
|
|
144 nil t))
|
|
|
145 (if (not (string-match "\\`\\[\\|::" feature-tag))
|
|
|
146 (re-search-forward (c++-class-definition-regexp class)
|
|
|
147 nil t)))))
|
|
|
148 (let ((found) (start))
|
|
|
149 ;; Now look for feature expression.
|
|
|
150 (or regexp-flag (setq feature-tag
|
|
|
151 (c++-feature-signature-to-regexp feature-tag)))
|
|
|
152 (while (and (re-search-forward feature-tag nil t)
|
|
|
153 (setq start (match-beginning 0))
|
|
|
154 (not (setq found (not
|
|
|
155 (if (c-within-comment-p)
|
|
|
156 (progn (search-forward "*/" nil t)
|
|
|
157 t)))))))
|
|
|
158 (if found
|
|
|
159 (progn (goto-char start)
|
|
|
160 (skip-chars-forward " \t\n")
|
|
|
161 (c++-to-comments-begin)
|
|
|
162 (recenter 0)
|
|
|
163 (goto-char start)
|
|
|
164 t))))
|
|
|
165
|
|
|
166 (defun c++-feature-name-to-regexp (name)
|
|
|
167 "Converts routine NAME into a regular expression matching the routine's name tag."
|
|
|
168 (setq name (c++-feature-signature-to-regexp name))
|
|
|
169 (aset name (1- (length name)) ?\() ;; Match only to functions
|
|
|
170 name)
|
|
|
171
|
|
|
172 (defun c++-feature-signature-to-name (signature &optional with-class for-display)
|
|
|
173 "Extracts the feature name from SIGNATURE.
|
|
|
174 The feature's class name is dropped from signature unless optional WITH-CLASS
|
|
|
175 is non-nil. If optional FOR-DISPLAY is non-nil, a feature type character is
|
|
|
176 prepended to the name for display in a browser listing."
|
|
|
177 (let ((name))
|
|
|
178 (cond
|
|
|
179 ;; member
|
|
|
180 ((string-match c++-tag-fields-regexp signature)
|
|
|
181 (setq name (substring signature (match-beginning (if for-display 2 3))
|
|
|
182 (match-end 3)))
|
|
|
183 (if with-class
|
|
|
184 (setq name (concat
|
|
|
185 (substring signature (match-beginning 1) (match-end 1))
|
|
|
186 "::" name)))
|
|
|
187 ;; Remove any trailing whitespace.
|
|
|
188 (br-delete-space name))
|
|
|
189 ;;
|
|
|
190 ;; unknown
|
|
|
191 (t ;; Remove any trailing whitespace and add display prefix.
|
|
|
192 (setq name (br-delete-space signature))
|
|
|
193 (if for-display (c++-feature-add-prefix name "" signature) name)))))
|
|
|
194
|
|
|
195 (defun c++-feature-signature-to-regexp (signature)
|
|
|
196 "Given a C++ SIGNATURE, return regexp used to match to its definition."
|
|
|
197 (setq signature (regexp-quote signature))
|
|
|
198 (let ((prefix-info
|
|
|
199 (if (string-match c++-tag-fields-regexp signature)
|
|
|
200 (prog1 (substring signature (match-beginning 0) (match-end 0))
|
|
|
201 (setq signature (substring signature (match-end 0)))))))
|
|
|
202 (if (string-match "[^<>*& \t]+\\(<[^>]+>\\)::" signature)
|
|
|
203 ;; Method from a template class. Match to a method with the same
|
|
|
204 ;; number of template parameters, regardless of parameter names.
|
|
|
205 (let ((pre (substring signature 0 (match-beginning 1)))
|
|
|
206 (mid (substring signature (match-beginning 1) (match-end 1)))
|
|
|
207 (post (substring signature (match-end 1))))
|
|
|
208 (setq signature (concat pre (c++-template-args-regexp mid) post))))
|
|
|
209 (let ((pat) (i 0) (c) (len (length signature)))
|
|
|
210 (while (< i len)
|
|
|
211 (setq c (aref signature i)
|
|
|
212 pat (cond ((= c ? )
|
|
|
213 ;; Allow for possible single line comment
|
|
|
214 ;; following any whitespace, e.g. following
|
|
|
215 ;; each routine argument.
|
|
|
216 (concat pat "[ \t\n\^M]*\\(//.*\\)?"))
|
|
|
217 (t
|
|
|
218 (concat pat (char-to-string c))))
|
|
|
219 i (1+ i)))
|
|
|
220 (setq pat (concat prefix-info pat)))))
|
|
|
221
|
|
|
222 (defun c++-feature-tree-command-p (class-or-signature)
|
|
|
223 "Display definition of CLASS-OR-SIGNATURE if a signature and return t, else return nil."
|
|
|
224 (if (c++-routine-p class-or-signature)
|
|
|
225 (progn
|
|
|
226 (if (br-in-browser) (br-to-view-window))
|
|
|
227 (br-feature-found-p (br-feature-file class-or-signature)
|
|
|
228 class-or-signature))))
|
|
|
229
|
|
|
230 (defun c++-list-features (class &optional indent)
|
|
|
231 "Return sorted list of C++ feature tags lexically defined in CLASS."
|
|
|
232 (let ((obuf (current-buffer))
|
|
|
233 (features)
|
|
|
234 (class-tag (concat "\n" class c++-type-tag-separator))
|
|
|
235 feature)
|
|
|
236 (set-buffer (funcall br-find-file-noselect-function br-feature-tags-file))
|
|
|
237 (goto-char 1)
|
|
|
238 (if (or (null indent) (<= indent 2))
|
|
|
239 ;; Include all features.
|
|
|
240 (while (search-forward class-tag nil t)
|
|
|
241 (setq features (cons (br-feature-current) features)))
|
|
|
242 ;; Omit friend features which are not inherited since indent > 2.
|
|
|
243 (let ((friend-regexp (format "%s%% " c++-type-tag-separator)))
|
|
|
244 (while (search-forward class-tag nil t)
|
|
|
245 (setq feature (br-feature-current))
|
|
|
246 (or (string-match friend-regexp feature)
|
|
|
247 (setq features (cons feature features))))))
|
|
|
248 (set-buffer obuf)
|
|
|
249 (c++-sort-features (nreverse features))))
|
|
|
250
|
|
|
251 (defun c++-routine-p (str)
|
|
|
252 (string-match "([^\)]*)" str))
|
|
|
253
|
|
|
254 (defun c++-scan-features ()
|
|
|
255 "Return reverse ordered list of C++ routine definitions in current buffer.
|
|
|
256 Assume point is at beginning of widened buffer."
|
|
|
257 (save-excursion
|
|
|
258 (let ((routines) class name rout)
|
|
|
259 (while (re-search-forward c++-routine-def nil t)
|
|
|
260 (setq class ""
|
|
|
261 name (buffer-substring (match-beginning c++-feature-name-grpn)
|
|
|
262 (match-end c++-feature-name-grpn)))
|
|
|
263 ;;
|
|
|
264 ;; This code is very subtle but it does the right thing so don't
|
|
|
265 ;; change it unless you know exactly what you are doing.
|
|
|
266 (if (not (match-beginning c++-feature-scope-grpn))
|
|
|
267 ;; This is a non-class function since we did not find a ::
|
|
|
268 ;; scoping operator.
|
|
|
269 (setq class "[function]")
|
|
|
270 ;; Is a member function, but this may set class = "" since prior
|
|
|
271 ;; regexp grouping may have grabbed the type. Be careful to
|
|
|
272 ;; handle this.
|
|
|
273 (setq class (buffer-substring
|
|
|
274 (match-beginning c++-feature-scope-grpn)
|
|
|
275 (- (match-end c++-feature-scope-grpn) 2)))
|
|
|
276 (if (and (string-equal class "")
|
|
|
277 (match-beginning c++-feature-type-grpn))
|
|
|
278 (setq class (buffer-substring
|
|
|
279 (match-beginning c++-feature-type-grpn)
|
|
|
280 (match-end c++-feature-type-grpn)))))
|
|
|
281
|
|
|
282 (setq rout (buffer-substring (match-beginning 0) (match-end 0)))
|
|
|
283 (if (c-within-comment-p)
|
|
|
284 (search-forward "*/" nil t)
|
|
|
285 ;; Move point to precede feature opening brace or pure virtual
|
|
|
286 ;; function declaration semicolon.
|
|
|
287 (backward-char)
|
|
|
288 (if (= (following-char) ?\{)
|
|
|
289 (condition-case ()
|
|
|
290 ;; Move to end of feature but ignore any error if braces are
|
|
|
291 ;; unbalanced. Let the compiler tell the user about this.
|
|
|
292 (forward-sexp)
|
|
|
293 (error nil)))
|
|
|
294 ;; Ignore matches to class constructs.
|
|
|
295 (if (string-match c++-class-name-before rout)
|
|
|
296 nil
|
|
|
297 (setq rout (c++-feature-normalize rout class name)
|
|
|
298 routines (cons rout routines)))))
|
|
|
299 routines)))
|
|
|
300
|
|
|
301 (defun c++-sort-features (routine-list)
|
|
|
302 (sort routine-list 'c++-feature-lessp))
|
|
|
303
|
|
|
304 (defun c++-to-definition (&optional other-win)
|
|
|
305 "If point is within a declaration, try to move to its definition.
|
|
|
306 With OTHER-WIN non-nil, show it in another window."
|
|
|
307 (interactive)
|
|
|
308 (let ((opoint (point)))
|
|
|
309 (cond
|
|
|
310 ((c++-include-file other-win))
|
|
|
311 ((br-check-for-class (c++-class-decl-p) other-win))
|
|
|
312 ((c++-feature other-win))
|
|
|
313 ((and (goto-char opoint)
|
|
|
314 (br-check-for-class (c++-find-class-name) other-win)))
|
|
|
315 (t (beep)
|
|
|
316 (message
|
|
|
317 "(OO-Browser): Select a C++ declaration to move to its definition.")
|
|
|
318 nil))))
|
|
|
319
|
|
|
320 ;;; ************************************************************************
|
|
|
321 ;;; Private functions
|
|
|
322 ;;; ************************************************************************
|
|
|
323
|
|
|
324 (defun c++-class-decl-p ()
|
|
|
325 "Return nil unless point is within a class declaration, referenced by another
|
|
|
326 class. Commented declarations also return nil. When value is non-nil, it is
|
|
|
327 the class name from the declaration. Leave point at start of statement for
|
|
|
328 visual clarity."
|
|
|
329 (c++-skip-to-statement)
|
|
|
330 (save-excursion
|
|
|
331 (let ((class))
|
|
|
332 (and (looking-at c++-class-decl)
|
|
|
333 (setq class (buffer-substring
|
|
|
334 (match-beginning c++-class-name-grpn)
|
|
|
335 (match-end c++-class-name-grpn)))
|
|
|
336 (if (match-beginning c++-decl-template-grpn)
|
|
|
337 (setq class
|
|
|
338 (c++-get-class-name
|
|
|
339 class (buffer-substring
|
|
|
340 (match-beginning c++-decl-template-grpn)
|
|
|
341 (match-end c++-decl-template-grpn))
|
|
|
342 t))
|
|
|
343 t)
|
|
|
344 (not (c-within-comment-p))
|
|
|
345 (progn (beginning-of-line)
|
|
|
346 (not (looking-at "[ \t]*//")))
|
|
|
347 class))))
|
|
|
348
|
|
|
349 (defun c++-feature (&optional other-win)
|
|
|
350 "Move point to definition of member given by declaration at point.
|
|
|
351 Return nil if point is not within a member declaration."
|
|
|
352 ;; If '{' follows the feature declaration, then feature is defined right
|
|
|
353 ;; here, within the class definition.
|
|
|
354 (interactive)
|
|
|
355 (let ((feature-def) (ftr) (class) (ftr-pat))
|
|
|
356 (cond ((c++-feature-def-p)
|
|
|
357 (recenter 0)
|
|
|
358 t)
|
|
|
359 ((c++-view-friend other-win t))
|
|
|
360 ;; Now look for feature definition in code (non-header) files.
|
|
|
361 ((progn (setq feature-def (c++-feature-def-pat)
|
|
|
362 ftr (car (cdr (cdr feature-def)))
|
|
|
363 class (car (cdr feature-def))
|
|
|
364 ftr-pat (car feature-def))
|
|
|
365 (c++-locate-feature ftr class ftr-pat other-win)))
|
|
|
366 ((c++-feature-decl)
|
|
|
367 (beep)
|
|
|
368 (message "(OO-Browser): '%s' feature definition not found." ftr)
|
|
|
369 t))))
|
|
|
370
|
|
|
371 (defun c++-view-friend (&optional other-win sig-at-point-flag)
|
|
|
372 "With point on a friend listing entry, view its source code definition.
|
|
|
373 With optional OTHER-WIN non-nil, display in another window.
|
|
|
374 With optional SIG-AT-POINT-FLAG non-nil, assume point is within a friend
|
|
|
375 signature in a source buffer."
|
|
|
376 (interactive)
|
|
|
377 (let ((tag
|
|
|
378 (if (not sig-at-point-flag)
|
|
|
379 (br-feature-get-signature)
|
|
|
380 (beginning-of-line)
|
|
|
381 (and (looking-at c++-friend-regexp)
|
|
|
382 (looking-at c++-friend-in-class)
|
|
|
383 (let ((friend (buffer-substring (match-beginning 0)
|
|
|
384 (match-end 0)))
|
|
|
385 (class (c++-get-class-name-from-source)))
|
|
|
386 (c++-feature-normalize
|
|
|
387 friend class
|
|
|
388 (c++-feature-signature-to-name friend) t))))))
|
|
|
389 (cond ((or (null tag)
|
|
|
390 ;; Not a friend entry.
|
|
|
391 (/= ?% (aref (c++-feature-signature-to-name tag nil t) 0)))
|
|
|
392 nil)
|
|
|
393 ((= ?\{ (aref tag (1- (length tag))))
|
|
|
394 ;; Friend is defined where declared.
|
|
|
395 (br-feature nil 'view tag)
|
|
|
396 t)
|
|
|
397 ((string-match (format " class \\(%s\\) ?;$"
|
|
|
398 c++-return-type-identifier) tag)
|
|
|
399 ;; friend class
|
|
|
400 (br-view nil nil
|
|
|
401 (c++-normalize-template-arguments
|
|
|
402 (substring tag (match-beginning 1) (match-end 1))))
|
|
|
403 t)
|
|
|
404 (t
|
|
|
405 (if sig-at-point-flag
|
|
|
406 nil ;; Other feature location code will handle this.
|
|
|
407 (br-feature nil t tag) ;; Move point to friend declaration.
|
|
|
408 (c++-feature other-win))))))
|
|
|
409
|
|
|
410 (defun c++-feature-add-prefix (feature-name class signature &optional friend-flag)
|
|
|
411 "Add a browser listing display prefix to FEATURE-NAME from CLASS based on feature's SIGNATURE."
|
|
|
412 (concat (cond (friend-flag "% ")
|
|
|
413 ((string-match c++-pure-virtual-function-regexp signature)
|
|
|
414 "> ")
|
|
|
415 ((or (= ?~ (aref feature-name 0))
|
|
|
416 (equal feature-name (c++-class-non-template-name class))
|
|
|
417 (br-member feature-name
|
|
|
418 '("operator new" "operator delete")))
|
|
|
419 "+ ")
|
|
|
420 (t "- "))
|
|
|
421 feature-name))
|
|
|
422
|
|
|
423 (defun c++-feature-decl ()
|
|
|
424 (if (looking-at c++-class-decl)
|
|
|
425 nil
|
|
|
426 (looking-at c++-feature-decl)))
|
|
|
427
|
|
|
428 (defun c++-feature-def-p ()
|
|
|
429 "Return nil unless point is within a member definition.
|
|
|
430 Commented member definitions also return nil.
|
|
|
431 Leaves point at start of statement for visual clarity."
|
|
|
432 (c++-skip-to-statement)
|
|
|
433 (save-excursion
|
|
|
434 (and (not (c-within-comment-p))
|
|
|
435 (save-excursion (beginning-of-line)
|
|
|
436 (not (looking-at "[ \t]*//")))
|
|
|
437 (not (looking-at c++-class-decl))
|
|
|
438 (looking-at (concat c++-at-feature-regexp "[{;,]"))
|
|
|
439 (let ((end-punct))
|
|
|
440 (or (= ?{
|
|
|
441 (setq end-punct (save-excursion (goto-char (match-end 0))
|
|
|
442 (preceding-char))))
|
|
|
443 ;; If ends with a '[;,]' then must not have func parens
|
|
|
444 ;; nor simply be a scoped name in order to be a def.
|
|
|
445 ;; If it begins with 'virtual', ends with "= 0" and has
|
|
|
446 ;; parens, then is a deferred virtual function declaration.
|
|
|
447 (if (match-end c++-feature-parens-grpn)
|
|
|
448 (save-restriction
|
|
|
449 (narrow-to-region (match-beginning 0) (match-end 0))
|
|
|
450 (if (looking-at
|
|
|
451 "\\(^\\|[ \t]+\\)virtual[ \t].*=[ \t]*0[ \t]*[,;]")
|
|
|
452 (progn (message "(OO-Browser): Pure virtual function, definition deferred to descendants.")
|
|
|
453 t)))
|
|
|
454 (or (null (match-end c++-feature-scope-grpn))
|
|
|
455 (not (equal (concat
|
|
|
456 (buffer-substring
|
|
|
457 (match-beginning c++-feature-scope-grpn)
|
|
|
458 (match-end c++-feature-name-grpn))
|
|
|
459 (char-to-string end-punct))
|
|
|
460 (buffer-substring (match-beginning 0)
|
|
|
461 (match-end 0)))))))))))
|
|
|
462
|
|
|
463 (defun c++-feature-def-pat ()
|
|
|
464 "Return (list <feature-def-pat> <feature-class> <feature-name>) associated with declaration at point."
|
|
|
465 (and (c++-skip-to-statement)
|
|
|
466 (c++-feature-decl)
|
|
|
467 ;; Don't regexp-quote member-name yet
|
|
|
468 (let* ((member-name (buffer-substring
|
|
|
469 (match-beginning c++-feature-name-grpn)
|
|
|
470 (match-end c++-feature-name-grpn)))
|
|
|
471 (member-modifiers (if (match-end c++-feature-mod-grpn)
|
|
|
472 (br-quote-match c++-feature-mod-grpn)))
|
|
|
473 (scoped-name)
|
|
|
474 (class)
|
|
|
475 (member-type
|
|
|
476 (concat (and (match-end c++-feature-type-grpn)
|
|
|
477 ;; Handle possible regexp bug
|
|
|
478 (not
|
|
|
479 (equal
|
|
|
480 (match-beginning c++-feature-type-grpn)
|
|
|
481 (match-beginning c++-feature-name-grpn)))
|
|
|
482 (concat (br-quote-match
|
|
|
483 c++-feature-type-grpn)))
|
|
|
484 (if (match-end c++-feature-scope-grpn)
|
|
|
485 (progn (setq scoped-name t
|
|
|
486 class (buffer-substring
|
|
|
487 (match-beginning
|
|
|
488 c++-feature-scope-grpn)
|
|
|
489 (- (match-end
|
|
|
490 c++-feature-scope-grpn)
|
|
|
491 2)))
|
|
|
492 (if (equal class "")
|
|
|
493 (setq class nil))
|
|
|
494 nil))))
|
|
|
495 (func-args (if (match-end c++-feature-parens-grpn)
|
|
|
496 (cons (match-beginning c++-feature-parens-grpn)
|
|
|
497 (match-end c++-feature-parens-grpn))))
|
|
|
498 (base-cl-args (match-end c++-feature-parens-grpn))
|
|
|
499 (friend)
|
|
|
500 )
|
|
|
501 (and member-type (string-match "[ \t]+$" member-type)
|
|
|
502 (setq member-type (substring member-type 0
|
|
|
503 (match-beginning 0))))
|
|
|
504 ;;
|
|
|
505 ;; Allow for different whitespace between declaration and definition
|
|
|
506 ;; when * or & is part of name and/or type, e.g. "char* id" and "char
|
|
|
507 ;; *id".
|
|
|
508 (if (and (stringp member-type)
|
|
|
509 (string-match "[*&]+$" member-type))
|
|
|
510 (setq member-type
|
|
|
511 (concat (substring member-type 0 (match-beginning 0))
|
|
|
512 "[ \t\n]*" (regexp-quote
|
|
|
513 (substring member-type
|
|
|
514 (match-beginning 0))))))
|
|
|
515 (if (string-match "^[*&]+" member-name)
|
|
|
516 (setq member-name (substring member-name (match-end 0))
|
|
|
517 member-type (concat member-type "[ \t\n]*"
|
|
|
518 (regexp-quote
|
|
|
519 (substring member-name 0
|
|
|
520 (match-end 0)))
|
|
|
521 "[ \t\n]*"))
|
|
|
522 (and (stringp member-type)
|
|
|
523 (not (equal member-type ""))
|
|
|
524 (setq member-type (concat member-type "[ \t\n]*"))))
|
|
|
525
|
|
|
526 (let ((pre-member-regexp
|
|
|
527 (concat
|
|
|
528 c++-template-prefix
|
|
|
529 "\\(\\(auto\\|inline\\|overload\\|static\\|virtual\\)[ \t\n]+\\)?"
|
|
|
530 (if member-modifiers
|
|
|
531 (let ((def-mods "") (mod))
|
|
|
532 (while (string-match "\\([a-z]+\\)[ \t\n]+"
|
|
|
533 member-modifiers)
|
|
|
534 (setq mod (substring member-modifiers
|
|
|
535 (match-beginning 1)
|
|
|
536 (match-end 1))
|
|
|
537 member-modifiers (substring member-modifiers
|
|
|
538 (match-end 0)))
|
|
|
539 (if (not friend)
|
|
|
540 (setq friend (string-equal mod "friend")))
|
|
|
541 (if (equal (string-match
|
|
|
542 c++-type-def-modifier mod) 0)
|
|
|
543 (setq def-mods (concat def-mods "\\(" mod
|
|
|
544 "[ \t\n]+\\)?"))))
|
|
|
545 def-mods))
|
|
|
546 (if (equal (string-match "virtual" member-type) 0)
|
|
|
547 nil member-type)))
|
|
|
548 (post-member-regexp
|
|
|
549 (concat
|
|
|
550 ;; Point at beginning of line may imply a non-member func.
|
|
|
551 (if (or scoped-name (not (bolp))) "::")
|
|
|
552 (progn (cond (scoped-name)
|
|
|
553 (friend
|
|
|
554 (progn
|
|
|
555 (if member-type
|
|
|
556 (progn
|
|
|
557 (setq class
|
|
|
558 (string-match c++-identifier
|
|
|
559 member-type))
|
|
|
560 (if class (setq class
|
|
|
561 (substring
|
|
|
562 member-type
|
|
|
563 class
|
|
|
564 (match-end 0))))))))
|
|
|
565 ;; Class name is not part of declaration
|
|
|
566 ;; nor a 'friend' declaration, so look
|
|
|
567 ;; for declaration within a class
|
|
|
568 ;; definition and locate the class name.
|
|
|
569 ;; If not within a class, assume
|
|
|
570 ;; declaration is global.
|
|
|
571 (t
|
|
|
572 (setq class (c++-get-class-name-from-source))))
|
|
|
573 (br-regexp-quote member-name))
|
|
|
574 "[ \t\n]*"
|
|
|
575 (if func-args
|
|
|
576 (concat "\\(" (c++-func-args-regexp func-args)
|
|
|
577 "\\|" (c++-func-args-string func-args)
|
|
|
578 "\\)"))
|
|
|
579 ;; If is a constructor member function, then can have some
|
|
|
580 ;; arguments for base class constructors after a ':'
|
|
|
581 ;; but preceding the '{'.
|
|
|
582 "[ \t\n]*"
|
|
|
583 (and base-cl-args
|
|
|
584 (equal member-name class)
|
|
|
585 "\\(:[^;{}]*\\)?")
|
|
|
586 c++-comment-regexp)))
|
|
|
587 (list
|
|
|
588 (` (lambda (class)
|
|
|
589 (concat "^" (br-regexp-quote class)
|
|
|
590 (, (concat
|
|
|
591 c++-type-tag-separator
|
|
|
592 br-feature-type-regexp " "
|
|
|
593 (br-regexp-quote member-name)
|
|
|
594 c++-type-tag-separator
|
|
|
595 pre-member-regexp))
|
|
|
596 (br-regexp-quote class)
|
|
|
597 (, post-member-regexp))))
|
|
|
598 class member-name)))))
|
|
|
599
|
|
|
600 (defun c++-feature-lessp (routine1 routine2)
|
|
|
601 (string-lessp (c++-feature-signature-to-name routine1)
|
|
|
602 (c++-feature-signature-to-name routine2)))
|
|
|
603
|
|
|
604 (defun c++-feature-matches (regexp)
|
|
|
605 "Return an unsorted list of feature tags whose names match in part or whole to REGEXP."
|
|
|
606 ;; Ensure match to feature names only; also handle "^" and "$" meta-chars
|
|
|
607 (setq regexp
|
|
|
608 (concat (format "^[^%s \n]+%s%s "
|
|
|
609 c++-type-tag-separator c++-type-tag-separator
|
|
|
610 br-feature-type-regexp)
|
|
|
611 (if (equal (substring regexp 0 1) "^")
|
|
|
612 (progn (setq regexp (substring regexp 1)) nil)
|
|
|
613 c++-identifier-chars)
|
|
|
614 (if (equal (substring regexp -1) "$")
|
|
|
615 (substring regexp 0 -1)
|
|
|
616 (concat regexp c++-identifier-chars))
|
|
|
617 c++-type-tag-separator))
|
|
|
618 (save-excursion
|
|
|
619 (set-buffer (funcall br-find-file-noselect-function br-feature-tags-file))
|
|
|
620 (goto-char 1)
|
|
|
621 (let ((features))
|
|
|
622 (while (re-search-forward regexp nil t)
|
|
|
623 (setq features (cons (br-feature-current) features)))
|
|
|
624 features)))
|
|
|
625
|
|
|
626 (defun c++-feature-normalize (routine class name &optional friend-flag)
|
|
|
627 (setq class (br-delete-space class)
|
|
|
628 name (c++-feature-add-prefix name class routine friend-flag)
|
|
|
629 routine (concat class c++-type-tag-separator
|
|
|
630 name c++-type-tag-separator
|
|
|
631 (br-delete-space routine)))
|
|
|
632 (let* ((len (length routine))
|
|
|
633 (normal-feature (make-string len ?\ ))
|
|
|
634 (n 0) (i 0)
|
|
|
635 (space-list '(?\ ?\t ?\n ?\^M))
|
|
|
636 (space-regexp "[ \t\n\^M]+")
|
|
|
637 chr)
|
|
|
638 (while (< i len)
|
|
|
639 (setq chr (aref routine i))
|
|
|
640 (cond
|
|
|
641 ;; Convert sequences of space characters to a single space.
|
|
|
642 ((memq chr space-list)
|
|
|
643 (aset normal-feature n ?\ )
|
|
|
644 (if (string-match space-regexp routine i)
|
|
|
645 (setq i (match-end 0)
|
|
|
646 n (1+ n))
|
|
|
647 (setq i (1+ i)
|
|
|
648 n (1+ n))))
|
|
|
649 ;;
|
|
|
650 ;; Remove // style comments
|
|
|
651 ((and (= chr ?/)
|
|
|
652 (< (1+ i) len)
|
|
|
653 (= (aref routine (1+ i)) ?/))
|
|
|
654 (setq i (+ i 2))
|
|
|
655 (while (and (< i len) (/= (aref routine i) ?\n))
|
|
|
656 (setq i (1+ i))))
|
|
|
657 (t ;; Normal character
|
|
|
658 (aset normal-feature n chr)
|
|
|
659 (setq i (1+ i)
|
|
|
660 n (1+ n)))))
|
|
|
661 (substring normal-feature 0 n)))
|
|
|
662
|
|
|
663 (defun c++-feature-tag-class (signature)
|
|
|
664 "Extract the class name from SIGNATURE."
|
|
|
665 (cond ((string-match c++-type-tag-separator signature)
|
|
|
666 (substring signature 0 (match-beginning 0)))
|
|
|
667 ((string-match "\\([^ \t]+\\)::" signature)
|
|
|
668 (substring signature (match-beginning 1) (match-end 1)))
|
|
|
669 (t "")))
|
|
|
670
|
|
|
671 (defun c++-feature-tags-lookup (class-list ftr-pat &optional other-win)
|
|
|
672 "Display routine definition derived from CLASS-LIST, matching FTR-PAT.
|
|
|
673 Use routine tags table to locate a match. Caller must use 'set-buffer'
|
|
|
674 to restore prior buffer when a match is not found."
|
|
|
675 (set-buffer (funcall br-find-file-noselect-function br-feature-tags-file))
|
|
|
676 (let ((classes class-list)
|
|
|
677 (found-ftr)
|
|
|
678 (ftr-regexp)
|
|
|
679 (class)
|
|
|
680 (ftr-path))
|
|
|
681 (if (or (null class-list) (equal class-list '(nil)))
|
|
|
682 nil
|
|
|
683 (while (and (not found-ftr) classes)
|
|
|
684 (setq class (car classes)
|
|
|
685 ftr-regexp (funcall ftr-pat class)
|
|
|
686 ftr-path (br-feature-def-file ftr-regexp)
|
|
|
687 found-ftr (if ftr-path
|
|
|
688 (br-edit-feature (br-feature-current)
|
|
|
689 ftr-path other-win))
|
|
|
690 classes (if found-ftr nil (cdr classes))))
|
|
|
691 (if found-ftr
|
|
|
692 (or class t)
|
|
|
693 (c++-feature-tags-lookup
|
|
|
694 (apply 'append (mapcar (function (lambda (cl) (br-get-parents cl)))
|
|
|
695 class-list))
|
|
|
696 ftr-pat)))))
|
|
|
697
|
|
|
698 (defun c++-files-with-source (class)
|
|
|
699 "Use CLASS to compute set of files that match to a C++ source file regexp.
|
|
|
700 Return as a list."
|
|
|
701 (let ((file (if class (br-class-path class) buffer-file-name)))
|
|
|
702 (and file
|
|
|
703 (let* ((src-file-regexp (concat "^" (br-filename-head file)
|
|
|
704 c++-code-file-regexp))
|
|
|
705 (dir (file-name-directory file))
|
|
|
706 (files (directory-files dir nil src-file-regexp)))
|
|
|
707 (mapcar (function (lambda (f) (concat dir f)))
|
|
|
708 files)))))
|
|
|
709
|
|
|
710 (defun c++-find-ancestors-feature (class-list ftr-pat &optional other-win)
|
|
|
711 "Scan ancestors of CLASS-LIST and show routine definition matching FTR-PAT."
|
|
|
712 ;; If no class, search for non-member function.
|
|
|
713 (or class-list (setq class-list '(nil)))
|
|
|
714 (let ((obuf (current-buffer)))
|
|
|
715 (prog1
|
|
|
716 (if (and br-feature-tags-file
|
|
|
717 (file-exists-p br-feature-tags-file)
|
|
|
718 (file-readable-p br-feature-tags-file))
|
|
|
719 (c++-feature-tags-lookup class-list ftr-pat other-win)
|
|
|
720 ;; Only works if features are in same directory as class def.
|
|
|
721 (c++-scan-ancestors-feature class-list ftr-pat other-win))
|
|
|
722 (set-buffer obuf))))
|
|
|
723
|
|
|
724 (defun c++-find-class-name ()
|
|
|
725 "Return current word as a potential class name."
|
|
|
726 (save-excursion
|
|
|
727 (let* ((start)
|
|
|
728 (ignore "\]\[ \t\n;,.\(\){}*&-")
|
|
|
729 (pat (concat "^" ignore)))
|
|
|
730 (forward-char 1)
|
|
|
731 (skip-chars-backward ignore)
|
|
|
732 (skip-chars-backward pat)
|
|
|
733 (setq start (point))
|
|
|
734 (skip-chars-forward (concat pat ":"))
|
|
|
735 (buffer-substring start (point)))))
|
|
|
736
|
|
|
737 (defun c++-func-args-regexp (func-args)
|
|
|
738 (let* ((space "\\\\\\s-*")
|
|
|
739 (obuf (current-buffer))
|
|
|
740 (tmp-buf-nm "*br-c++-tmp*")
|
|
|
741 (tmp-buf (progn (if (get-buffer tmp-buf-nm)
|
|
|
742 (kill-buffer tmp-buf-nm))
|
|
|
743 (get-buffer-create tmp-buf-nm))))
|
|
|
744 (or tmp-buf (error "OO-Browser: (c++-func-args-regexp) - Can't create tmp-buf."))
|
|
|
745 ;; Fill tmp-buffer with all func-args, including parens.
|
|
|
746 (copy-to-buffer tmp-buf (car func-args) (cdr func-args))
|
|
|
747
|
|
|
748 (set-buffer tmp-buf)
|
|
|
749 (let ((quoted-args (br-regexp-quote (buffer-substring
|
|
|
750 (point-min) (point-max)))))
|
|
|
751 (erase-buffer)
|
|
|
752 (insert quoted-args))
|
|
|
753
|
|
|
754 (goto-char (point-min))
|
|
|
755 (if (looking-at "(\\s-*)")
|
|
|
756 (replace-match "(\\\\s-*)" t)
|
|
|
757
|
|
|
758 ;; Replace all "\( +" with "\(" temporarily
|
|
|
759 (br-buffer-replace "\\(^\\|[^\\]\\)\([ \t\n]+" "\\1\(")
|
|
|
760
|
|
|
761 ;; Replace all "+ \)" with "\)" temporarily
|
|
|
762 (br-buffer-replace "[ \t\n]+\)" "\)")
|
|
|
763
|
|
|
764 ;; Replace all "...\)" with "...@" temporarily
|
|
|
765 (br-buffer-replace "\\\\\\.\\\\\\.\\\\\\.\)" "@@@")
|
|
|
766
|
|
|
767 ;; Optionalize right hand side of argument assignments.
|
|
|
768 (br-buffer-replace "\\([^=,\( \t\n]+\\)\\([ \t\n]*=[^,\)]+\\)"
|
|
|
769 (concat "\\1\\\\( "
|
|
|
770 (br-regexp-quote c++-arg-identifier)
|
|
|
771 "\\\\)? \\\\(\\2\\\\)?"))
|
|
|
772
|
|
|
773 ;; Replace all "\)" with "optional <c++-identifier> \)"
|
|
|
774 (br-buffer-replace
|
|
|
775 "\\([\(,][^=\)]+\\)\)"
|
|
|
776 (concat "\\1\\\\( " (br-regexp-quote c++-arg-identifier)
|
|
|
777 "\\\\)?\)"))
|
|
|
778
|
|
|
779 ;; Replace all "," with "optional <c++-identifier>,"
|
|
|
780 (br-buffer-replace
|
|
|
781 "\\([\(,][^=,]+\\),"
|
|
|
782 (concat "\\1\\\\( " (br-regexp-quote c++-arg-identifier) "\\\\)?,"))
|
|
|
783
|
|
|
784 ;; Replace all " *, *" with "<spc>,<spc>"
|
|
|
785 (br-buffer-replace "[ \t\n]*,[ \t\n]*" (concat space "," space))
|
|
|
786
|
|
|
787 ;; Replace all " +" with "<spc>"
|
|
|
788 (br-buffer-replace "[ \t\n]+" space)
|
|
|
789
|
|
|
790 ;; Replace all "\(" with "\(<spc>"
|
|
|
791 (br-buffer-replace "\\(^\\|[^\\]\\)\(" (concat "\\1\(" space))
|
|
|
792
|
|
|
793 ;; Replace all "\)" with "<spc>\)"
|
|
|
794 (br-buffer-replace "\\([^\\]\\)\)" (concat "\\1" space "\)"))
|
|
|
795
|
|
|
796 ;; Replace all & and quoted \\* with "<spc>[*&]+<spc>"
|
|
|
797 (br-buffer-replace "\\(&\\|\\\\\\*\\)+" (concat space "\\1" space))
|
|
|
798
|
|
|
799 ;; Replace all "<spc>" with "[ \t\n]*"
|
|
|
800 (br-buffer-replace "\\\\s-\\*" "[ \t\n]*")
|
|
|
801
|
|
|
802 ;; Replace all "@@@" with any # of args
|
|
|
803 (br-buffer-replace "@@@" "[^\)]*\)")
|
|
|
804 )
|
|
|
805
|
|
|
806 ;; Return final buffer as a string.
|
|
|
807 (prog1 (buffer-substring (point-min) (point-max))
|
|
|
808 (kill-buffer tmp-buf-nm)
|
|
|
809 (set-buffer obuf))))
|
|
|
810
|
|
|
811 (defun c++-func-args-string (func-args)
|
|
|
812 (let* ((space "\\\\\\s-*")
|
|
|
813 (obuf (current-buffer))
|
|
|
814 (tmp-buf-nm "*br-c++-tmp*")
|
|
|
815 (tmp-buf (progn (if (get-buffer tmp-buf-nm)
|
|
|
816 (kill-buffer tmp-buf-nm))
|
|
|
817 (get-buffer-create tmp-buf-nm))))
|
|
|
818 (or tmp-buf (error "OO-Browser: (c++-func-args-string) - Can't create tmp-buf."))
|
|
|
819 ;; Fill tmp-buffer with all func-args, including parens.
|
|
|
820 (copy-to-buffer tmp-buf (car func-args) (cdr func-args))
|
|
|
821
|
|
|
822 (set-buffer tmp-buf)
|
|
|
823 (let ((quoted-args (br-regexp-quote (buffer-substring
|
|
|
824 (point-min) (point-max)))))
|
|
|
825 (erase-buffer)
|
|
|
826 (insert quoted-args))
|
|
|
827
|
|
|
828 (goto-char (point-min))
|
|
|
829 (if (looking-at "(\\s-*)")
|
|
|
830 (replace-match "(\\\\s-*)" t)
|
|
|
831
|
|
|
832 ;; Replace all "\( +" with "\(" temporarily
|
|
|
833 (br-buffer-replace "\\(^\\|[^\\]\\)\([ \t\n]+" "\\1\(")
|
|
|
834
|
|
|
835 ;; Replace all "+ \)" with "\)" temporarily
|
|
|
836 (br-buffer-replace "[ \t\n]+\)" "\)")
|
|
|
837
|
|
|
838 ;; Replace all "...\)" with "@@@" temporarily
|
|
|
839 (br-buffer-replace "\\\\\\.\\\\\\.\\\\\\.\)" "@@@")
|
|
|
840
|
|
|
841 ;; Optionalize right hand side of argument assignments.
|
|
|
842 (br-buffer-replace "\\([^=,\( \t\n]+\\)\\([ \t\n]+=[^,\)]+\\)"
|
|
|
843 (concat "\\1\\\\(\\2\\\\)?"))
|
|
|
844
|
|
|
845 ;; If an arg consists of 2 or more words, replace last with <identifier>
|
|
|
846 (br-buffer-replace
|
|
|
847 "\\([\(,][^=,\)]*[^ \t\n=,\)]+[ \t\n]+\\)[^ \t\n=,\)]+\\([ \t\n]*[,\)]\\)"
|
|
|
848 (concat "\\1" (br-regexp-quote c++-arg-identifier) "\\2"))
|
|
|
849
|
|
|
850 ;; If an arg consists of only 1 word, add a second
|
|
|
851 (br-buffer-replace
|
|
|
852 "\\([\(,][ \t\n]*\\)\\([^ \t\n=,\)]+\\)\\([ \t\n]*[,\)]\\)"
|
|
|
853 (concat "\\1\\2 " (br-regexp-quote c++-arg-identifier) "\\3"))
|
|
|
854
|
|
|
855 ;; Replace all " *, *" with "<spc>,<spc>"
|
|
|
856 (br-buffer-replace "[ \t\n]*,[ \t\n]*" (concat space "," space))
|
|
|
857
|
|
|
858 ;; Replace all " +" with "<spc>"
|
|
|
859 (br-buffer-replace "[ \t\n]+" space)
|
|
|
860
|
|
|
861 ;; Replace all "\(" with "\(<spc>"
|
|
|
862 (br-buffer-replace "\\(^\\|[^\\]\\)\(" (concat "\\1\(" space))
|
|
|
863
|
|
|
864 ;; Replace all "\)" with "<spc>\)"
|
|
|
865 (br-buffer-replace "\\([^\\]\\)\)" (concat "\\1" space "\)"))
|
|
|
866
|
|
|
867 ;; Replace all & and quoted \\* with "<spc>[*&]+<spc>"
|
|
|
868 (br-buffer-replace "\\(&\\|\\\\\\*\\)+" (concat space "\\1" space))
|
|
|
869
|
|
|
870 ;; Replace all "<spc>" with "[ \t\n]*"
|
|
|
871 (br-buffer-replace "\\\\s-\\*" "[ \t\n]*")
|
|
|
872
|
|
|
873 ;; Replace all "@@@" with any # of args
|
|
|
874 (br-buffer-replace "@@@" "[^\)]*\)")
|
|
|
875 )
|
|
|
876
|
|
|
877 ;; Return final buffer as a string.
|
|
|
878 (prog1 (buffer-substring (point-min) (point-max))
|
|
|
879 (kill-buffer tmp-buf-nm)
|
|
|
880 (set-buffer obuf))))
|
|
|
881
|
|
|
882 (defun c++-get-class-name-from-source ()
|
|
|
883 "Return class name from closest class definition preceding point or nil."
|
|
|
884 (let ((opoint (point))
|
|
|
885 (class))
|
|
|
886 (save-excursion
|
|
|
887 (if (re-search-backward c++-class-def-regexp nil t)
|
|
|
888 (progn (goto-char (match-beginning c++-class-def-derived-grpn))
|
|
|
889 (setq class (c++-normalize-class-match nil))
|
|
|
890 ;; Ensure that declaration occurs within class definition.
|
|
|
891 (forward-list)
|
|
|
892 (and (> (point) opoint)
|
|
|
893 class))))))
|
|
|
894
|
|
|
895 (defun c++-get-feature-tags (routine-file &optional routine-list)
|
|
|
896 "Scan C++ ROUTINE-FILE and hold routine tags in 'br-feature-tags-file'.
|
|
|
897 Assume ROUTINE-FILE has already been read into a buffer and that
|
|
|
898 'br-feature-tags-init' has been called. Optional ROUTINE-LIST can be
|
|
|
899 provided so that a non-standard scan function can be used before calling
|
|
|
900 this function."
|
|
|
901 (interactive)
|
|
|
902 (let ((obuf (current-buffer)))
|
|
|
903 (or routine-list
|
|
|
904 (setq routine-list (c++-sort-features (nreverse
|
|
|
905 (c++-scan-features)))))
|
|
|
906 (set-buffer (funcall br-find-file-noselect-function br-feature-tags-file))
|
|
|
907 (goto-char 1)
|
|
|
908 ;; Delete any prior routine tags associated with routine-file
|
|
|
909 (if (search-forward routine-file nil 'end)
|
|
|
910 (progn (forward-line -1)
|
|
|
911 (let ((start (point)))
|
|
|
912 (search-forward "\^L" nil 'end 2)
|
|
|
913 (backward-char 1)
|
|
|
914 (delete-region start (point))
|
|
|
915 )))
|
|
|
916 (if routine-list
|
|
|
917 (progn (insert "\^L\n" routine-file "\n")
|
|
|
918 (mapcar (function (lambda (tag) (insert tag "\n")))
|
|
|
919 routine-list)
|
|
|
920 ))
|
|
|
921 (set-buffer obuf)))
|
|
|
922
|
|
|
923 (defun c++-include-file (&optional other-win)
|
|
|
924 "If point is on an include file line, try to display file.
|
|
|
925 Return non-nil iff an include file line, even if file is not found.
|
|
|
926 Look for include file in 'c++-cpp-include-dirs' and in directory list
|
|
|
927 'c++-include-dirs'."
|
|
|
928 (let ((opoint (point)))
|
|
|
929 (beginning-of-line)
|
|
|
930 (if (looking-at c++-include-regexp)
|
|
|
931 (let ((incl-type (string-to-char
|
|
|
932 (buffer-substring (match-beginning 1)
|
|
|
933 (1+ (match-beginning 1)))))
|
|
|
934 (file (buffer-substring (match-beginning 2) (match-end 2)))
|
|
|
935 (path)
|
|
|
936 (dir-list c++-include-dirs)
|
|
|
937 (found))
|
|
|
938 (goto-char opoint)
|
|
|
939 (setq dir-list (if (= incl-type ?<)
|
|
|
940 (append dir-list c++-cpp-include-dirs)
|
|
|
941 (cons (file-name-directory buffer-file-name)
|
|
|
942 dir-list)))
|
|
|
943 (while dir-list
|
|
|
944 (setq path (concat (car dir-list) file)
|
|
|
945 dir-list (if (setq found (file-exists-p path))
|
|
|
946 nil
|
|
|
947 (cdr dir-list))))
|
|
|
948 ;;
|
|
|
949 ;; If not found in normal include dirs, check all Env paths also.
|
|
|
950 ;;
|
|
|
951 (if (not found)
|
|
|
952 (let ((paths (delq nil (hash-map 'cdr br-paths-htable))))
|
|
|
953 (while paths
|
|
|
954 (setq path (car paths))
|
|
|
955 (if (string-equal (file-name-nondirectory path) file)
|
|
|
956 (setq found t paths nil)
|
|
|
957 (setq paths (cdr paths))))))
|
|
|
958 ;;
|
|
|
959 ;; If found, display file
|
|
|
960 ;;
|
|
|
961 (if found
|
|
|
962 (if (file-readable-p path)
|
|
|
963 (progn
|
|
|
964 (funcall br-edit-file-function path other-win)
|
|
|
965 (if (not (fboundp 'br-lang-mode))
|
|
|
966 (c++-mode-setup))
|
|
|
967 (br-major-mode))
|
|
|
968 (beep)
|
|
|
969 (message "(OO-Browser): Include file '%s' unreadable." path))
|
|
|
970 (beep)
|
|
|
971 (message "(OO-Browser): Include file '%s' not found." file))
|
|
|
972 path)
|
|
|
973 (goto-char opoint)
|
|
|
974 nil)))
|
|
|
975
|
|
|
976 (defun c++-locate-feature (ftr class ftr-pat &optional other-win)
|
|
|
977 ;; 'class' may = nil, implying non-member function
|
|
|
978 (or class (setq class "[function]"))
|
|
|
979 (let ((def-class))
|
|
|
980 (if (and ftr-pat
|
|
|
981 (setq def-class
|
|
|
982 (c++-find-ancestors-feature (list class)
|
|
|
983 ftr-pat other-win)))
|
|
|
984 (progn (if (and class (not (equal class def-class)))
|
|
|
985 (message
|
|
|
986 "Member `%s` of class '%s' inherited from class '%s'."
|
|
|
987 ftr class def-class))
|
|
|
988 t))))
|
|
|
989
|
|
|
990 (defun c++-scan-ancestors-feature (class-list ftr-pat &optional other-win)
|
|
|
991 "Display routine definition derived from CLASS-LIST, matching FTR-PAT.
|
|
|
992 Scan files with same base name as class file."
|
|
|
993 (let ((classes class-list)
|
|
|
994 (found-ftr)
|
|
|
995 (code-def-files)
|
|
|
996 (file)
|
|
|
997 (ftr-regexp)
|
|
|
998 (class))
|
|
|
999 (if (null class-list)
|
|
|
1000 nil
|
|
|
1001 (while (and (not found-ftr) classes)
|
|
|
1002 (setq class (car classes)
|
|
|
1003 code-def-files (c++-files-with-source class)
|
|
|
1004 ftr-regexp (funcall ftr-pat class))
|
|
|
1005 (while (and (setq file (car code-def-files))
|
|
|
1006 (not (setq found-ftr
|
|
|
1007 (br-feature-found-p file ftr-regexp
|
|
|
1008 nil other-win t))))
|
|
|
1009 (setq code-def-files (cdr code-def-files)))
|
|
|
1010 (setq classes (if found-ftr nil (cdr classes))))
|
|
|
1011 (if found-ftr
|
|
|
1012 (or class t)
|
|
|
1013 (c++-scan-ancestors-feature
|
|
|
1014 (apply 'append (mapcar (function (lambda (cl) (br-get-parents cl)))
|
|
|
1015 class-list))
|
|
|
1016 ftr-pat)))))
|
|
|
1017
|
|
|
1018 (defun c++-scan-features-in-class (class start end)
|
|
|
1019 "Return reverse ordered list of C++ routine definitions within CLASS def.
|
|
|
1020 START and END give buffer region to search."
|
|
|
1021 (setq class (br-delete-space class))
|
|
|
1022 (save-excursion
|
|
|
1023 (save-restriction
|
|
|
1024 (narrow-to-region start end)
|
|
|
1025 (goto-char start)
|
|
|
1026 (let ((routines) rout name type)
|
|
|
1027 ;;
|
|
|
1028 ;; Get member definitions and pure virtual declarations.
|
|
|
1029 ;;
|
|
|
1030 (while (re-search-forward c++-routine-def-in-class nil t)
|
|
|
1031 (setq start (match-beginning 0)
|
|
|
1032 name (buffer-substring
|
|
|
1033 (match-beginning c++-feature-name-grpn)
|
|
|
1034 (match-end c++-feature-name-grpn))
|
|
|
1035 type (if (match-beginning c++-feature-type-grpn)
|
|
|
1036 (buffer-substring
|
|
|
1037 (match-beginning c++-feature-type-grpn)
|
|
|
1038 (match-end c++-feature-type-grpn)))
|
|
|
1039 rout (buffer-substring (match-beginning 0) (match-end 0))
|
|
|
1040 ;; Do this after done getting groupings from the search.
|
|
|
1041 type (if type (br-delete-space type)))
|
|
|
1042 ;; This is necessary to remove a possible double expression match
|
|
|
1043 ;; where there is a blank line within the match.
|
|
|
1044 (if (string-match "[\n\^M]\\([ \t]*[\n\^M]\\)+" rout)
|
|
|
1045 (progn (setq rout (substring rout (match-end 0)))
|
|
|
1046 (goto-char (+ start (match-end 0))))
|
|
|
1047 (if (c-within-comment-p)
|
|
|
1048 (search-forward "*/" nil t)
|
|
|
1049 ;; Move point to precede feature opening brace or pure virtual
|
|
|
1050 ;; function declaration semicolon.
|
|
|
1051 (backward-char)
|
|
|
1052 (if (= (following-char) ?\{)
|
|
|
1053 (condition-case ()
|
|
|
1054 ;; Move to end of feature but ignore any error if braces
|
|
|
1055 ;; are unbalanced. Let the compiler tell the user about
|
|
|
1056 ;; this.
|
|
|
1057 (forward-sexp)
|
|
|
1058 (error nil)))
|
|
|
1059 (if (string-match c++-friend-regexp rout)
|
|
|
1060 ;; skip friends until later
|
|
|
1061 nil
|
|
|
1062 ;; Handle type conversion ops: operator int() { return i; }
|
|
|
1063 (if (equal type "operator") (setq name (concat type " " name)
|
|
|
1064 type nil))
|
|
|
1065 (setq rout (c++-feature-normalize rout class name)
|
|
|
1066 routines (cons rout routines))))))
|
|
|
1067 ;;
|
|
|
1068 ;; Get friend declarations.
|
|
|
1069 ;;
|
|
|
1070 (goto-char (point-min))
|
|
|
1071 (while (re-search-forward c++-friend-regexp nil t)
|
|
|
1072 (beginning-of-line)
|
|
|
1073 (if (not (looking-at c++-friend-in-class))
|
|
|
1074 nil
|
|
|
1075 (setq start (match-beginning 0)
|
|
|
1076 name (buffer-substring
|
|
|
1077 (match-beginning c++-feature-name-grpn)
|
|
|
1078 (match-end c++-feature-name-grpn))
|
|
|
1079 type (if (match-beginning c++-feature-type-grpn)
|
|
|
1080 (buffer-substring
|
|
|
1081 (match-beginning c++-feature-type-grpn)
|
|
|
1082 (match-end c++-feature-type-grpn)))
|
|
|
1083 rout (buffer-substring (match-beginning 0) (match-end 0))
|
|
|
1084 ;; Do this after done getting groupings from the search.
|
|
|
1085 type (if type (br-delete-space type)))
|
|
|
1086 ;; This is necessary to remove a possible double expression match
|
|
|
1087 ;; where there is a blank line within the match.
|
|
|
1088 (if (string-match "[\n\^M]\\([ \t]*[\n\^M]\\)+" rout)
|
|
|
1089 (progn (setq rout (substring rout (match-end 0)))
|
|
|
1090 (goto-char (+ start (match-end 0))))
|
|
|
1091 (if (c-within-comment-p)
|
|
|
1092 (search-forward "*/" nil t)
|
|
|
1093 ;; Handle type conversion ops: operator int() { return i; }
|
|
|
1094 (if (equal type "operator") (setq name (concat type " " name)
|
|
|
1095 type nil))
|
|
|
1096 (setq rout (c++-feature-normalize rout class name t)
|
|
|
1097 routines (cons rout routines)))))
|
|
|
1098 ;; Move to next entry.
|
|
|
1099 (or (= (forward-line 1) 0) (end-of-line)))
|
|
|
1100 routines))))
|
|
|
1101
|
|
|
1102 (defun c++-skip-past-comments ()
|
|
|
1103 "Skip over comments immediately following point."
|
|
|
1104 (skip-chars-forward " \t\n")
|
|
|
1105 (while
|
|
|
1106 (cond ((looking-at "//")
|
|
|
1107 (equal (forward-line 1) 0))
|
|
|
1108 ((looking-at "/\\*")
|
|
|
1109 (re-search-forward "\\*/" nil t))
|
|
|
1110 (t nil))))
|
|
|
1111
|
|
|
1112 (defun c++-skip-to-statement ()
|
|
|
1113 (if (re-search-backward "\\(^\\|[;{}]\\)[ \t]*" nil t)
|
|
|
1114 (progn (goto-char (match-end 0))
|
|
|
1115 (skip-chars-forward " \t")
|
|
|
1116 t)))
|
|
|
1117
|
|
|
1118 ;;; ************************************************************************
|
|
|
1119 ;;; Private variables
|
|
|
1120 ;;; ************************************************************************
|
|
|
1121
|
|
|
1122 (defconst c++-code-file-regexp "\\.\\(cxx\\|[cC][cC]?P?\\)$"
|
|
|
1123 "Regular expression matching a unique part of C++ source (non-header) file name and no others.")
|
|
|
1124
|
|
|
1125 (defconst c++-include-regexp
|
|
|
1126 "[ \t/*]*#[ \t]*include[ \t]+\\([\"<]\\)\\([^\">]+\\)[\">]"
|
|
|
1127 "Regexp to match to C++ include file lines. File name is grouping 2. Type
|
|
|
1128 of include, user-specified via double quote, or system-related starting with
|
|
|
1129 '<' is given by grouping 1.")
|
|
|
1130
|
|
|
1131 (defconst c++-type-def-modifier
|
|
|
1132 "\\(auto\\|const\\|inline\\|mutable\\|register\\|static\\|typedef\\)")
|
|
|
1133
|
|
|
1134 (defconst c++-type-modifier-keyword
|
|
|
1135 (concat "\\(\\(auto\\|const\\|explicit\\|extern[ \t\n\^M]+\"[^\"]+\"\\|"
|
|
|
1136 "extern\\|friend\\|inline\\|mutable\\|overload\\|"
|
|
|
1137 "register\\|static\\|typedef\\|virtual\\)[ \t\n\^M]+\\)"))
|
|
|
1138
|
|
|
1139 (defconst c++-member-modifier-keyword
|
|
|
1140 "\\(\\([ \t\n\^M]+const\\|[ \t\n\^M]+mutable\\)?\\([ \t\n\^M]*[=:][^;{]+\\)?\\)")
|
|
|
1141
|
|
|
1142 (defconst c++-type-identifier-group
|
|
|
1143 ;; It is critical that the final part of this expression, [*& \t\n\^M]+,
|
|
|
1144 ;; stay exactly as it is or certain feature definitions may be missed or
|
|
|
1145 ;; segmented improperly.
|
|
|
1146 ;; If you remove the '*&', "Int &operator=(int j) {}", will not be found
|
|
|
1147 ;; because the & will be missed. If you change the '+' to a '*', "main()"
|
|
|
1148 ;; will show up as "- n" in listing buffers.
|
|
|
1149 (concat "\\(\\(" c++-return-type-identifier "\\)[*& \t\n\^M]+\\)"))
|
|
|
1150
|
|
|
1151 (defconst c++-function-identifier (concat
|
|
|
1152 "[_~<a-zA-Z][^][ \t:;.,~{}()]*")
|
|
|
1153 "Regular expression matching a C++ or G++ function name.")
|
|
|
1154
|
|
|
1155 ;; Old def = "operator[ \t]*[^]) \t:;.,?~{}][^[( \t:;.,~^!|?{}]?[=*]?"
|
|
|
1156 ;; Final optional expression is to handle new C++ array operators, e.g.
|
|
|
1157 ;; void operator delete [] (void*);
|
|
|
1158 (defconst c++-operator-identifier "operator[ \t\n\^M]*[^ \t\n\^M:;.,?~{}]+\\([ \t\n\^M]*\\[\\]\\)?"
|
|
|
1159 "Regular expression matching a C++ or G++ operator name.")
|
|
|
1160
|
|
|
1161 (defconst c++-feature-decl-or-def
|
|
|
1162 (concat c++-template-prefix
|
|
|
1163 "\\(" c++-type-modifier-keyword "*"
|
|
|
1164 c++-type-identifier-group "\\)?"
|
|
|
1165 "\\(" c++-type-identifier "[ \t\n\^M]*\\)?"
|
|
|
1166 "\\(" c++-operator-identifier "\\|" c++-function-identifier "\\|"
|
|
|
1167 "[*&]?" c++-identifier "\\)"
|
|
|
1168 ;; This old version of the next line matched to things such as:
|
|
|
1169 ;; enum name {};. Since we don't deal with attributes yet and
|
|
|
1170 ;; since such matches improperly end up in the [function] default
|
|
|
1171 ;; class, we only accept matches with () in them.
|
|
|
1172 ;; "[ \t\n\^M]*\\(\\[[^{;]+\\|([^{;]*)"
|
|
|
1173 "[ \t\n\^M]*\\(([^{;]*)"
|
|
|
1174 c++-member-modifier-keyword "?\\)")
|
|
|
1175 "Regexp matching a C++ member declaration or definition.
|
|
|
1176 Member modifier keywords are grouped expression 'c++-feature-mode-grpn'.
|
|
|
1177 Member type is grouped expression 'c++-feature-type-grpn', unless scoping
|
|
|
1178 type name, grouped expression 'c++-feature-scope-grpn' is non-nil, in which
|
|
|
1179 case, grouping 'c++-feature-scope-grpn' is the type plus \"::\".
|
|
|
1180 Member name is group 'c++-feature-name-grpn'. Function parentheses, if any,
|
|
|
1181 are group 'c++-feature-parens-grpn'.")
|
|
|
1182
|
|
|
1183 (defconst c++-feature-mod-grpn 3)
|
|
|
1184 (defconst c++-feature-type-grpn 6)
|
|
|
1185 (defconst c++-feature-scope-grpn 10)
|
|
|
1186 (defconst c++-feature-name-grpn 11)
|
|
|
1187 (defconst c++-feature-parens-grpn 14)
|
|
|
1188
|
|
|
1189 (defconst c++-at-feature-regexp
|
|
|
1190 (concat c++-feature-decl-or-def c++-comment-regexp)
|
|
|
1191 "See documentation of 'c++-feature-decl-or-def' for grouping expressions.")
|
|
|
1192
|
|
|
1193 (defconst c++-feature-decl
|
|
|
1194 (concat c++-at-feature-regexp ";")
|
|
|
1195 "See documentation of 'c++-feature-decl-or-def' for grouping expressions.")
|
|
|
1196
|
|
|
1197 (defconst c++-friend-in-class
|
|
|
1198 (concat "[ \t]*" c++-at-feature-regexp "[{;]")
|
|
|
1199 "See documentation of 'c++-feature-decl-or-def' for grouping expressions.
|
|
|
1200 This doesn't limit matches to friends. See 'c++-friend-regexp' for that.")
|
|
|
1201
|
|
|
1202 (defconst c++-friend-regexp "^[^(){}\n\^M]*[ \t]friend[ \t\n\^M]"
|
|
|
1203 "Regexp matching a C++ friend declaration or definition at the start of a line or the start of a string.")
|
|
|
1204
|
|
|
1205 (defconst c++-routine-def-terminator-regexp
|
|
|
1206 ;; Also matches to pure virtual function declarations.
|
|
|
1207 "\\({\\|[ \t\n\^M]*=[ \t]*0[ \t]*;\\)")
|
|
|
1208
|
|
|
1209 (defconst c++-routine-def
|
|
|
1210 (concat "^" c++-at-feature-regexp c++-routine-def-terminator-regexp)
|
|
|
1211 "See documentation of 'c++-feature-decl-or-def' for grouping expressions.")
|
|
|
1212
|
|
|
1213 (defconst c++-routine-def-in-class
|
|
|
1214 (concat "^[ \t]*" c++-at-feature-regexp c++-routine-def-terminator-regexp)
|
|
|
1215 "See documentation of 'c++-feature-decl-or-def' for grouping expressions.")
|
|
|
1216
|
|
|
1217 (defconst c++-class-modifier-keyword
|
|
|
1218 "\\(\\(friend\\|public\\|protected\\)[ \t\n\^M]+\\)")
|
|
|
1219
|
|
|
1220 (defconst c++-class-decl
|
|
|
1221 (concat c++-class-modifier-keyword "?"
|
|
|
1222 c++-template-prefix
|
|
|
1223 c++-class-keyword c++-identifier "[ \t]*[;,]")
|
|
|
1224 "Regexp matching a C++ class declaration.
|
|
|
1225 Template match, if any, is grouping 'c++-decl-template-grpn'.
|
|
|
1226 Class name is grouping 'c++-class-name-grpn'.")
|
|
|
1227
|
|
|
1228 (defconst c++-decl-template-grpn 3)
|
|
|
1229 (defconst c++-class-name-grpn 5)
|
|
|
1230
|
|
|
1231 (defconst c++-arg-identifier
|
|
|
1232 (concat "[_a-zA-Z][" c++-identifier-chars "]*")
|
|
|
1233 "Regular expression matching a C++ or G++ function argument identifier.")
|
|
|
1234
|
|
|
1235 (defconst c++-pure-virtual-function-regexp "\)[^=]*=[ \t]*0[ \t]*;\\'"
|
|
|
1236 "Regexp matching the trailing part of a C++ pure virtual function signature.")
|
|
|
1237
|
|
|
1238 (provide 'br-c++-ft)
|
