Emacs/cc-ide: Better file #define symbol generation from complete subdirectory and...
[emacsstuff.git] / cc-ide / cc-helper.el
1 ;;; cc-helper.el --- helper and generator functions for C++
2 ;;
3 ;; $Id$
4 ;;
5 ;; Copyright (C) 2000 Stefan Bund
6
7 ;; cc-helper.el is free software; you can redistribute it and/or
8 ;; modify it under the terms of the GNU General Public License as
9 ;; published by the Free Software Foundation; either version 2, or (at
10 ;; your option) any later version.
11
12 ;; cc-helper.el is distributed in the hope that it will be useful, but
13 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 ;; General Public License for more details.
16
17 ;;; Commentary:
18
19 ;;; Change-Log:
20
21 ;; $Log$
22 ;;
23
24 ;;; Variables:
25
26 (defvar c-max-def-column 95
27   "*Maximum length of generated argdef lines")
28
29 (defconst c-special-key "\\(static\\|virtual\\|friend\\|explicit\\)\\b")
30
31 ;;; Code:
32
33 (require 'cc-engine-2)
34 (require 'cc-vars)
35
36 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
37 ;; generators (functions generating new sourcecode)
38
39 (defun c-kill-special-keywords ()
40   ;; kill all keywords in c-special-key directly after point
41   (c-forward-syntactic-ws)
42   (while (looking-at c-special-key)
43     (delete-region (point) (match-end 1))
44     (delete-region (point) (progn (c-forward-syntactic-ws) (point)))))
45
46 (defun c-build-template-specs (templates cbuf)
47   ;; build temlate specs for TEMPLATES
48   (loop for template in templates
49         do (insert 
50             (save-excursion
51               (set-buffer cbuf)
52               (save-excursion
53                 (goto-char (car template))
54                 (let ((args (c-parse-template-declaration)))
55                   (if args
56                       (concat "template <"
57                               (loop for arg in args
58                                     for sep = "" then ", "
59                                     concat sep
60                                     concat (progn
61                                              (buffer-substring-no-properties
62                                               (car arg) (if (c-move-to-initializer 
63                                                              (car arg) (cdr arg))
64                                                             (progn 
65                                                               (forward-char -1)
66                                                               (c-backward-syntactic-ws)
67                                                               (point))
68                                                           (cdr arg)))))
69                               ">\n")
70                     "")))))))
71
72 (defun c-build-defun (&optional add-words no-kill)
73   ;; build a function definition header for the current defun. if
74   ;; ADD-WORDS is non-nil, it is prepended to the definition header
75   ;; after any template specifications. the return value is a cons of
76   ;; the name of the function and the complete text of the header.
77   ;; c-build-defun tries hard to keep the with of the declaration
78   ;; below c-max-def-column
79   (save-excursion
80     (c-beginning-of-defun-or-decl)
81     (let* ((tbuf (get-buffer-create " *cc-temp-buffer*"))
82            (state (c-get-defun-state))
83            (prefix (c-get-full-prefix (aref state 8)))
84            (cbuf (current-buffer))
85            p1 p2 p3 c maxc fname)
86       (set-buffer tbuf)
87       (erase-buffer)
88       (c-build-template-specs (aref state 0) cbuf)
89       (if (aref state 1)
90           (progn
91             (save-excursion
92               (insert-buffer-substring cbuf (car (aref state 1)) (cdr (aref state 1)))
93               (insert " "))
94             (if (not no-kill)
95                 (progn
96                   (c-kill-special-keywords)))))
97       (if add-words
98           (progn
99             (insert add-words " ")))
100       (goto-char (point-max))
101       (setq p1 (point))
102       (insert prefix)
103       (if (> (length prefix) 0)
104           (progn
105             (insert "::")
106             (setq p2 (point))))
107       (save-excursion
108         (insert-buffer-substring cbuf (car (aref state 2)) (cdr (aref state 2))))
109       (save-excursion
110         (while (re-search-forward "\\s-+" nil t)
111           (replace-match "")))
112       (if (not p2)
113           (progn
114             (c-with-temporary-syntax-table c-mode-syntax-table
115               (setq p2 (car (last (c-forward-scoped-name))))
116               (if p2
117                   (setq p2 (+ p2 2))))))
118       (goto-char (point-max))
119       (setq fname (buffer-substring-no-properties p1 (point)))
120       (if (> (current-column) c-max-def-column)
121           (progn
122             (goto-char p1)
123             (delete-char -1)
124             (insert "\n")
125             (end-of-line)
126             (setq p1 nil)))
127       (insert "(")
128       (setq p3 (point))
129       (setq c (current-column)
130             maxc 0)
131       (insert "\n")
132       (loop for arg in (aref state 3)
133             for next = nil then t
134             if next do (insert ",\n")
135             do (progn
136                  (save-excursion
137                    (insert-buffer-substring cbuf (car arg) (cdr arg)))
138                  (save-excursion
139                    (if (search-forward "=" nil t)
140                        (progn
141                          (forward-char -1)
142                          (c-backward-syntactic-ws)
143                          (forward-char 1)
144                          (delete-region (1- (point)) (progn (end-of-line) (point))))))
145                  (replace-regexp "\\s-+" " ")
146                  (end-of-line)
147                  (let ((cc (current-column)))
148                    (if (> cc maxc)
149                        (setq maxc cc)))))
150       (if (> (+ c maxc) c-max-def-column)
151           (progn
152             (if (and p1
153                      (progn
154                        (goto-char p1)
155                        (> (1- (current-column))
156                           (- (+ c maxc) c-max-def-column))))
157                 (progn
158                   (delete-char -1)
159                   (insert "\n"))
160               (if p2
161                   (progn
162                     (goto-char p2)
163                     (insert "\n")
164                     (setq p3 (1+ p3)))))))
165       (goto-char p3)
166       (setq c (current-column))
167       (loop for next = nil then t
168             for p = (point)
169             while (not (eobp))
170             do (progn
171                  (if next (insert " "))
172                  (delete-char 1)
173                  (end-of-line)
174                  (if (and next (> (current-column) c-max-def-column))
175                      (progn
176                        (goto-char p)
177                        (delete-char 1)
178                        (insert "\n" (make-string c ? ))
179                        (end-of-line)))))
180       (insert ")")
181       (if (aref state 4)
182           (progn
183             (insert "\n    ")
184             (save-excursion
185               (insert-buffer-substring cbuf (car (aref state 4)) (cdr (aref state 4))))
186             (replace-regexp "\\s-+" " ")
187             (end-of-line)))
188       (if (aref state 5)
189           (progn
190             (insert "\n    : ")
191             (loop with first = t
192                   for initializer in (aref state 5)
193                   for next = nil then t
194                   for p = (point)
195                   do (progn
196                        (if next (insert ", "))
197                        (save-excursion
198                          (insert-buffer-substring cbuf (car initializer) 
199                                                   (cdr initializer)))
200                        (replace-regexp "\\s-+" " ")
201                        (end-of-line)
202                        (if (not first)
203                            (if (> (current-column) c-max-def-column)
204                                (progn
205                                  (goto-char (1+ p))
206                                  (delete-char 1)
207                                  (insert "\n      ")
208                                  (setq first t)
209                                  (end-of-line)))
210                          (setq first nil))))))
211       (prog1
212           (list fname 
213                 (buffer-substring-no-properties (point-min) (point-max))
214                 state)
215         (kill-buffer tbuf)))))
216
217 (defun c-build-create-constructor ()
218   (save-excursion
219     (c-beginning-of-defun-or-decl)
220     (let* ((tbuf (get-buffer-create " *cc-temp-buffer*"))
221            (cbuf (current-buffer))
222            (state (c-get-defun-state))
223            (indent (make-string (current-indentation) ? ))
224            (fname (buffer-substring-no-properties (car (aref state 2))
225                                                   (cdr (aref state 2)))))
226       (set-buffer tbuf)
227       (if (aref state 1)
228           (error "Not a constructor"))
229       (insert indent "static ptr create(")
230       (let ((indent2 (make-string (current-column) ? ))
231             ml)
232         (save-excursion
233           (insert "\n")
234           (loop for arg in (aref state 3)
235                 for next = nil then t
236                 if next do (insert ",\n")
237                 do (progn
238                      (save-excursion
239                        (insert-buffer-substring cbuf (car arg) (cdr arg)))
240                      (replace-regexp "\\s-+" " ")
241                      (end-of-line))))
242         (loop for next = nil then t
243               for p = (point)
244               while (not (eobp))
245               do (progn
246                    (if next (insert " "))
247                    (delete-char 1)
248                    (end-of-line)
249                    (if (and next (> (current-column) c-max-def-column))
250                        (progn
251                          (setq ml t)
252                          (goto-char p)
253                          (delete-char 1)
254                          (insert "\n" indent2)
255                          (end-of-line)))))
256         (insert ")");
257         (if (aref state 4)
258             (progn
259               (insert " ")
260               (let ((p (point)))
261                 (save-excursion
262                   (insert-buffer-substring cbuf 
263                                            (car (aref state 4))
264                                            (cdr (aref state 4))))
265                 (replace-regexp "\\s-+" " ")
266                 (end-of-line)
267                 (if (or ml (> (current-column) c-max-def-column))
268                     (progn
269                       (goto-char p)
270                       (insert "\n" indent (make-string c-basic-offset ? ))
271                       (end-of-line))))))
272         (insert ";\n"))
273       (prog1
274           (list "create"
275                 (buffer-substring-no-properties (point-min) (point-max))
276                 state)
277         (kill-buffer tbuf)))))
278
279 (defun c-build-create-constructor-impl (&optional add-words no-kill)
280   (save-excursion
281     (let* ((proto (c-build-defun add-words no-kill))
282            (cbuf (current-buffer))
283            (tbuf (get-buffer-create " *cc-temp-buffer*"))
284            (indent (make-string c-basic-offset ? )))
285       (set-buffer tbuf)
286       (erase-buffer)
287       (insert (nth 1 proto) "\n{\n" indent "return ptr(new "
288               (save-excursion
289                 (set-buffer cbuf)
290                 (c-scope-name (aref (car (last (aref (nth 2 proto) 8))) 1)))
291               "(")
292       (let ((indent2 (make-string (current-column) ? )))
293         (save-excursion
294           (insert "\n")
295           (loop for arg in (aref (nth 2 proto) 3)
296                 for next = nil then t
297                 if next do (insert ",\n")
298                 do (insert (save-excursion
299                              (set-buffer cbuf)
300                              (c-get-template-argument-name (car arg) (cdr arg))))))
301         (loop for next = nil then t
302               for p = (point)
303               while (not (eobp))
304               do (progn
305                    (if next (insert " "))
306                    (delete-char 1)
307                    (end-of-line)
308                    (if (and next (> (current-column) c-max-def-column))
309                        (progn
310                          (goto-char p)
311                          (delete-char 1)
312                          (insert "\n" indent2)
313                          (end-of-line)))))
314         (insert "));\n}\n"))
315       (prog1
316           (list (car proto)
317                 (buffer-substring-no-properties (point-min) (point-max))
318                 (cdr proto))
319         (kill-buffer tbuf)))))
320
321 (eval-when-compile (autoload 'ccide-reformat-defun "cc-ide"))
322
323 (defun c-build-default-funcions-impl ()
324   (save-excursion
325     (let* ((scope (c-get-block-scope))
326            (templates (c-get-templates scope))
327            (prefix (c-get-full-prefix scope))
328            (class (c-parse-class scope))
329            (bases (c-get-base-classes class))
330            (variables (c-get-variable-members class))
331            (name (c-scope-name (aref (car (last scope)) 1)))
332            (in (make-string c-basic-offset ? ))
333            (cbuf (current-buffer))
334            (tbuf (get-buffer-create " *cc-temp-buffer-2*"))
335            template-specs)
336       (set-buffer tbuf)
337       (erase-buffer)
338       (c-build-template-specs templates cbuf)
339       (setq template-specs (buffer-substring (point-min) (point-max)))
340       (save-excursion 
341         (insert "prefix_ " prefix "::" name "()\n")
342         (if ccide-gen-throw
343             (insert in "throw_(())\n"))
344         (insert "{}\n"
345                 "\n"))
346       (ccide-reformat-defun)
347       (goto-char (point-max))
348       (insert template-specs)
349       (save-excursion
350         (insert "prefix_ " prefix "::" name "(const " name "& other)\n")
351         (if ccide-gen-throw
352             (insert in "throw_(())\n"))
353         (insert in ": " 
354                 (mapconcat (function (lambda (x) (concat x "(other)")))
355                            bases ", ")
356                 (if (and bases variables) ", " "")
357                 (mapconcat (function (lambda (x) (concat x "(other." x ")")))
358                            variables ", ")
359                 "\n{}\n\n"))
360       (ccide-reformat-defun)
361       (goto-char (point-max))
362       (insert template-specs)
363       (save-excursion
364         (insert "prefix_ " prefix " & " prefix "::operator=(const " 
365                 name "& other)\n")
366         (if ccide-gen-throw
367             (insert in "throw_(())\n"))
368         (insert "{\n"
369                 (mapconcat (function (lambda (x) 
370                                        (concat in "*((" x "*)this) = other;\n")))
371                            bases "")
372                 (mapconcat (function (lambda (x)
373                                        (concat in x " = other." x ";\n")))
374                            variables "")
375                 in "return *this"
376                 "}\n\n"))
377       (ccide-reformat-defun)
378       (goto-char (point-max))
379       (insert template-specs)
380       (save-excursion
381         (insert "prefix_ " prefix "::~" name "()\n{}\n"))
382       (ccide-reformat-defun)
383       (prog1
384           (list prefix
385                 (buffer-substring-no-properties (point-min) (point-max)))
386         (kill-buffer tbuf)))))
387
388 (provide 'cc-helper)
389
390 \f
391 ;;; Local Variables:
392 ;;; elisp-project-autoload-file-name: "cc-autoload.el"
393 ;;; End: