cc-ide/cc-ide.el

   1 ;;; cc-ide.el --- C++ IDE
   2 ;;
   3 ;; $Id$
   4 ;;
   5 ;; Copyright (C) 2000 Stefan Bund
   6
   7 ;; cc-ide.el is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published
   9 ;; by the Free Software Foundation; either version 2, or (at your
  10 ;; option) any later version.
  11
  12 ;; cc-ide.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 ccide-compile-opts "DEBUG=1"
  27   "*Additional options to make command")
  28
  29 (defvar ccide-file-vars nil)
  30
  31 (defvar ccide-default-author "")
  32 (defvar ccide-default-copyright "")
  33
  34 (defvar ccide-corba-skel-dir "")
  35 (defvar ccide-corba-idl-dir "")
  36 (defvar ccide-corba-idl-command "omniidl2 -w")
  37
  38 (defvar c-user-prefixes '("inline" "static" "prefix_")
  39   "*List of possible prefixes for function definitions.")
  40
  41 (defvar ccide-default-prefix "prefix_"
  42   "*Prefix added to every implementation header. Probably eiter empty or 'prefix_'")
  43
  44 (defvar ccide-gen-throw nil
  45   "*If non-nil, generate throw_ specs")
  46
  47 (defvar ccide-project-root)
  48
  49 (defconst c-user-prefix-re (regexp-opt c-user-prefixes t))
  50
  51 (defconst ccide-doxy-tag-re
  52   (concat "\\\\\\(group\\|defgroup\\|see\\|author\\|version\\|id\\|since"
  53           "\\|returns?\\|throws?\\|exception\\|raises\\|param\\|li\\|brief"
  54           "\\|internal\\|bug\\|fixme\\|todo\\|idea\\|implementation"
  55           "\\|note\\|attention\\|warning\\|par\\|code\\|endcode"
  56           "\\|post\\|pre\\)\\b"))
  57
  58 (defconst ccide-special-extensions
  59   '(".h" ".hh" ".mpp" ".ih" ".cc" ".cpp" ".ct" ".cti" ".cci" ".dox"))
  60
  61 (defconst ccide-implementation-extensions
  62   '(".h" ".hh" ".ih" ".cc" ".cpp" ".ct" ".cti" ".cci"))
  63
  64 (defconst ccide-class-defaults-word
  65   "// \\(default\\|no\\|protected\\|private\\|disabled\\|my\\)")
  66
  67 (defconst  ccide-bindings
  68   '(
  69     ;; file level
  70     ("fc"  ccide-file-comment                 "File comment")
  71     ("fs"  ccide-syncronize-includes          "Sync includes")
  72     (nil   nil                                separator)
  73
  74     ;; class level
  75     ("cc"  ccide-class-comment                "Class comment")
  76     ("cg"  ccide-gen-class                    "Generate class")
  77     ("cd"  ccide-gen-class-defaults           "Generate class defaults")
  78     ("cD"  ccide-gen-class-defaults-impl      "Generate class defaults impl")
  79
  80     ("csd" ccide-set-class-defaults-default   "Set class defaults comment" "Default")
  81     ("csn" ccide-set-class-defaults-no        "Set class defaults comment" "No")
  82     ("csp" ccide-set-class-defaults-protected "Set class defaults comment" "Protected")
  83     ("csr" ccide-set-class-defaults-private   "Set class defaults comment" "Private")
  84     ("csx" ccide-set-class-defaults-disabled  "Set class defaults comment" "Disabled")
  85     ("csm" ccide-set-class-defaults-my        "Set class defaults comment" "My")
  86
  87     ("cS"  ccide-gen-struct-constructors      "Generate structure constructors")
  88
  89     ("ci"  ccide-class-impl-comment           "Generate class implemenation comment")
  90
  91     (nil   nil                                separator)
  92
  93     ;; method level
  94     ("mc"  ccide-function-comment             "Method comment")
  95     ("mp"  ccide-grab-prototype               "Grab prototype")
  96     ("mr"  ccide-reformat-defun               "Reformat defun")
  97     ("mx"  ccide-replace-defun                "Replace defun")
  98     ("mt"  ccide-prefix-defun-type-with-class "Prefix defun type with class")
  99     ("mn"  ccide-prefix-defun-type-with-namespace "Prefix defun type with namespace")
 100     ("mi"  ccide-grab-inline-decl             "Grab inline decl")
 101     ("mA"  ccide-grab-all-inlines             "Grab ALL inline decls")
 102     ("mC"  ccide-grab-create-constructor      "Grab CREATE constructor")
 103     ("mI"  ccide-grab-create-constructor-impl "Build CREATE cosntructor")
 104     ("mf"  ccide-find-implementation          "Find method implementation")
 105     ("mT"  ccide-insert-defun-prefix          "Insert current defun prefix at point")
 106     (nil   nil                                separator)
 107
 108     ;; variable level
 109     ("vc"  ccide-variable-comment             "Variable comment")
 110     ("vf"  ccide-grab-acces-fn                "Grab access methods")
 111     (nil   nil                                separator)
 112
 113     ;; documentation
 114     ("h"  ccide-hide-all-doxy-comments        "Hide all Doxygen comments")
 115     ("s"  ccide-show-all-comments             "Show all Doxygen comments")
 116
 117 ;    ;; CORBA
 118 ;    ("Cg"  ccide-gen-corba-impl                      "Generate CORBA impl")
 119 ;    ("Cm"  ccide-gen-corba-impl-methods       "Generate CORBA impl methods")
 120 ;    (nil   nil                               separator)
 121
 122     ;; templates
 123 ;    ("ts"  ccide-scan-mantemps               "Scan mantemps")
 124 ;    (nil   nil                                separator)
 125
 126 ;    ;; other
 127 ;    ("of"  ccide-open-compilation-frame       "Open *compilation* frame")
 128 ;    ("oc"  ccide-compile-compile              "Make -> Compile")
 129 ;    ("ox"  ccide-compile-clean                "Make -> Clean")
 130 ;    ("od"  ccide-compile-cleandepends         "Make -> Clean depends")
 131 ;    ("ok"  ccide-compile-kill                 "Kill compilation")
 132 ;    ("oh"  ccide-hide-compilation             "Hide *compilation* buffer")
 133
 134     ))
 135
 136 ;;; Code:
 137
 138 (require 'cc-engine-2)
 139 (require 'cc-helper)
 140 (require 'c++)
 141 (require 'cl)
 142 (require 'hideshow)
 143 ;(require 'mantemp)
 144 (require 'locate)
 145 (require 'lucid)
 146 (require 'varcmd)
 147 (require 'misc-local)
 148
 149 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 150 ;; utils
 151
 152 (defsubst ccide-match-string (n)
 153   (buffer-substring-no-properties (match-beginning n) (match-end n)))
 154
 155 (defun ccide-file-macro-name (&optional file-name)
 156   (concat (upcase (file-name-extension (or file-name (buffer-file-name))))
 157           "_"
 158           (string-replace "\\." "_" (file-name-sans-extension
 159                                      (file-name-nondirectory
 160                                       (or file-name (buffer-file-name))))
 161                           t nil t t)
 162           "_"))
 163
 164 (defun ccide-file-name (&optional extension file-name directory)
 165   (concat (if directory (file-name-as-directory directory) "")
 166           (file-name-sans-extension
 167            (file-name-nondirectory
 168             (or file-name (buffer-file-name))))
 169           extension))
 170
 171 (defun ccide-in-doxy-comment ()
 172   (save-excursion
 173     (back-to-indentation)
 174     (let ((lit (c-in-literal)))
 175       (if (cond ((eq lit 'c)
 176                  (goto-char (car (c-literal-limits)))
 177                  (looking-at "/\\*\\*<?[ \t\n\r@]"))
 178                 ((eq lit 'c++)
 179                  (goto-char (car (c-literal-limits)))
 180                  (looking-at "///<?[ \t\n\r@]"))
 181                 (t nil))
 182           (progn
 183             (goto-char (match-end 0))
 184             (current-column))))))
 185
 186 (defun ccide-shell-command (command)
 187   (let ((obuf (get-buffer-create "*ccide shell command*"))
 188         exit-status)
 189     (save-excursion
 190       (set-buffer obuf)
 191       (erase-buffer)
 192       (insert command "\n"))
 193     (setq exit-status (call-process shell-file-name nil "*ccide shell command*" nil
 194                                     shell-command-switch command))
 195     (and exit-status (equal exit-status 0))))
 196
 197 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 198 ;; file level
 199
 200 (defun ccide-file-comment ()
 201   "Add a comment to this source file."
 202   (interactive)
 203   (let ((mode "c++")
 204         point add-file-vars)
 205     (push-mark)
 206     (goto-char (point-min))
 207     (insert "// Copyright (C) " (number-to-string (nth 5 (decode-time)))
 208             " " ccide-default-author "\n"
 209             ccide-default-copyright
 210             "\n")
 211
 212     (cond ((string-match "\\.hh?$" (buffer-file-name))
 213            (insert "/** \\file\n"
 214                    "    \\brief " (ccide-file-name) " public header */\n\n"
 215                    "#ifndef " (ccide-file-macro-name) "\n"
 216                    "#define " (ccide-file-macro-name) " 1\n\n"
 217                    "// Custom includes\n\n"
 218                    "//#include \"" (ccide-file-name ".mpp") "\"\n"
 219                    "///////////////////////////////hh.p////////////////////////////////////////\n\n")
 220            (setq point (point))
 221            (goto-char (point-max))
 222            (insert "\n\n///////////////////////////////hh.e////////////////////////////////////////\n"
 223                    "//#include \"" (ccide-file-name ".cci") "\"\n"
 224                    "//#include \"" (ccide-file-name ".ct") "\"\n"
 225                    "//#include \"" (ccide-file-name ".cti") "\"\n"
 226                    "#endif"))
 227
 228           ((string-match "\\.mpp$" (buffer-file-name))
 229            (insert "/** \\file\n"
 230                    "    \\brief " (ccide-file-name) " Boost.Preprocesser external iteration include */\n\n"
 231
 232
 233                    "#if !BOOST_PP_IS_ITERATING && !defined(" (ccide-file-macro-name) ")\n"
 234                    "#define " (ccide-file-macro-name) " 1\n\n"
 235                    "// Custom includes\n\n\n"
 236                    "// ///////////////////////////mpp.p////////////////////////////////////////\n"
 237                    "#elif BOOST_PP_IS_ITERATING // ////////////////////////////////////////////\n"
 238                    "// ////////////////////////////////////////////////////////////////////////\n"
 239                    "// Local Macros\n\n\n"
 240                    "// ////////////////////////////////////////////////////////////////////////\n"
 241                    "#if BOOST_PP_ITERATION_FLAGS()==1 // //////////////////////////////////////\n"
 242                    "// ////////////////////////////////////////////////////////////////////////\n\n")
 243            (setq point (point))
 244            (goto-char (point-max))
 245            (insert "\n\n// ////////////////////////////////////////////////////////////////////////\n"
 246                    "#endif // /////////////////////////////////////////////////////////////////\n"
 247                    "// ////////////////////////////////////////////////////////////////////////\n"
 248                    "// Undefine local Macros\n\n\n"
 249                    "// ////////////////////////////////////////////////////////////////////////\n"
 250                    "#endif // /////////////////////////////////////////////////////////////////\n"
 251                    "// ///////////////////////////mpp.e////////////////////////////////////////"))
 252
 253           ((string-match "\\.ih$" (buffer-file-name))
 254            (insert "/** \\file\n"
 255                    "    \\brief " (ccide-file-name) " internal header */\n\n"
 256                    "#ifndef " (ccide-file-macro-name) "\n"
 257                    "#define " (ccide-file-macro-name) " 1\n\n"
 258                    "// Custom includes\n\n"
 259                    "///////////////////////////////ih.p////////////////////////////////////////\n\n")
 260            (setq point (point))
 261            (goto-char (point-max))
 262            (insert "\n\n///////////////////////////////ih.e////////////////////////////////////////\n"
 263                    "#endif"))
 264
 265           ((or (string-match "\\.test\\.cc$" (buffer-file-name))
 266                (string-match "\\.test\\.cpp$" (buffer-file-name)))
 267            (insert "/** \\file\n"
 268                    "    \\brief " (ccide-file-name) " unit tests */\n\n"
 269                    "//#include \"" (ccide-file-name ".hh") "\"\n"
 270                    "//#include \"" (ccide-file-name ".ih") "\"\n\n"
 271                    "// Custom includes\n"
 272                    "#include \"" (ccide-file-name ".hh" (ccide-file-name)) "\"\n\n"
 273                    "#include <boost/test/auto_unit_test.hpp>\n"
 274                    "#include <boost/test/test_tools.hpp>\n\n"
 275                    "#define prefix_\n"
 276                    "///////////////////////////////cc.p////////////////////////////////////////\n\n")
 277            (setq point (point))
 278            (goto-char (point-max))
 279            (insert "\n\n///////////////////////////////cc.e////////////////////////////////////////\n"
 280                    "#undef prefix_"))
 281
 282           ((or (string-match "\\.cc$" (buffer-file-name))
 283                (string-match "\\.cpp$" (buffer-file-name)))
 284            (insert "/** \\file\n"
 285                    "    \\brief " (ccide-file-name) " non-inline non-template implementation */\n\n"
 286                    "//#include \"" (ccide-file-name ".hh") "\"\n"
 287                    "//#include \"" (ccide-file-name ".ih") "\"\n\n"
 288                    "// Custom includes\n\n"
 289                    "//#include \"" (ccide-file-name ".mpp") "\"\n"
 290                    "#define prefix_\n"
 291                    "///////////////////////////////cc.p////////////////////////////////////////\n\n")
 292            (setq point (point))
 293            (goto-char (point-max))
 294            (insert "\n\n///////////////////////////////cc.e////////////////////////////////////////\n"
 295                    "#undef prefix_\n"
 296                    "//#include \"" (ccide-file-name ".mpp") "\""))
 297
 298           ((string-match "\\.cci$" (buffer-file-name))
 299            (insert "/** \\file\n"
 300                    "    \\brief " (ccide-file-name) " inline non-template implementation */\n\n"
 301                    "// Custom includes\n\n"
 302                    "#define prefix_ inline\n"
 303                    "///////////////////////////////cci.p///////////////////////////////////////\n\n")
 304            (setq point (point))
 305            (goto-char (point-max))
 306            (insert "\n\n///////////////////////////////cci.e///////////////////////////////////////\n"
 307                    "#undef prefix_"))
 308
 309           ((string-match "\\.ct$" (buffer-file-name))
 310            (insert "/** \\file\n"
 311                    "    \\brief " (ccide-file-name) " non-inline template implementation  */\n\n"
 312                    "//#include \"" (ccide-file-name ".ih") "\"\n\n"
 313                    "// Custom includes\n\n"
 314                    "#define prefix_\n"
 315                    "///////////////////////////////ct.p////////////////////////////////////////\n\n")
 316            (setq point (point))
 317            (goto-char (point-max))
 318            (insert "\n\n///////////////////////////////ct.e////////////////////////////////////////\n"
 319                    "#undef prefix_"))
 320
 321           ((string-match "\\.cti$" (buffer-file-name))
 322            (insert "/** \\file\n"
 323                    "    \\brief " (ccide-file-name) " inline template implementation */\n\n"
 324                    "//#include \"" (ccide-file-name ".ih") "\"\n\n"
 325                    "// Custom includes\n\n"
 326                    "#define prefix_ inline\n"
 327                    "///////////////////////////////cti.p///////////////////////////////////////\n\n")
 328            (setq point (point))
 329            (goto-char (point-max))
 330            (insert "\n\n///////////////////////////////cti.e///////////////////////////////////////\n"
 331                    "#undef prefix_"))
 332
 333           ((string-match "\\.dox$" (buffer-file-name))
 334            (insert "/** \\mainpage\n\n    ")
 335            (setq point (point))
 336            (insert "\n */")
 337            (setq add-file-vars '(( mode . flyspell)
 338                                  ( mode . auto-fill)
 339                                  ( ispell-local-dictionary . "american" ))))
 340
 341           ((string-match "\\.java$" (buffer-file-name))
 342            (setq mode "jde")
 343            (setq point (point))
 344            (goto-char (point-max)))
 345
 346           (t
 347            (setq point (point))
 348            (goto-char (point-max))))
 349
 350     (insert "\n\n\f\n"
 351             "// Local Variables:\n"
 352             "// mode: " mode "\n")
 353     (loop for (var . value) in ccide-file-vars
 354           do (insert "// " (symbol-name var) ": " (prin1-to-string value) "\n"))
 355     (loop for (var . value) in add-file-vars
 356           do (insert "// " (symbol-name var) ": " (prin1-to-string value) "\n"))
 357     (insert "// End:\n")
 358     (if point
 359         (goto-char point))
 360     (if (equal mode "jde")
 361         (let ((package (file-name-directory (buffer-file-name))))
 362           (jdeap-initialize-setup)
 363           (if (not (equal jdeap-current-source-directory "."))
 364               (if (string-match
 365                    (concat "^" (regexp-quote jdeap-current-source-directory))
 366                    package)
 367                   (progn
 368                     (setq package (substring package
 369                                              (match-end 0)
 370                                              (1- (length package))))
 371                     (insert "package "
 372                             (string-replace "/" "." package t)
 373                             ";\n\n"))))
 374           (insert "class " (file-name-sans-extension
 375                             (file-name-nondirectory
 376                              (buffer-file-name))) "\n{}")
 377           (beginning-of-line)))))
 378
 379 (defun ccide-syncronize-includes ()
 380   "Syncronize include's in all other files"
 381   (interactive)
 382   (let (buffer-map)
 383     (loop for extension in ccide-special-extensions
 384           for file-name = (ccide-file-name extension)
 385           do (setq buffer-map
 386                    (cons (cons file-name
 387                                (or (find-buffer-visiting file-name)
 388                                    (and (file-readable-p file-name)
 389                                         (find-file-noselect file-name))))
 390                          buffer-map)))
 391     (save-excursion
 392       (loop for buffer in buffer-map
 393             if (cdr buffer)
 394               do (progn
 395                    (set-buffer (cdr buffer))
 396                    (save-excursion
 397                      (loop for include in buffer-map
 398                            do (progn
 399                                 (goto-char (point-min))
 400                                 (while (re-search-forward
 401                                         (concat "^\\(//\\)?#\\s-*include \""
 402                                                 (regexp-quote (car include))
 403                                                 "\"\\s-*$")
 404                                         nil t)
 405                                   (goto-char (match-beginning 0))
 406                                   (if (looking-at "//")
 407                                       (if (cdr include)
 408                                           (delete-char 2))
 409                                     (if (not (cdr include))
 410                                         (insert "//")))
 411                                   (forward-line 1))))))))))
 412
 413 (defun ccide-auto-decorate-new-files ()
 414   (if (= (point-min) (point-max))
 415       (let ((status (buffer-modified-p)))
 416         (ccide-file-comment)
 417         (set-buffer-modified-p status))))
 418
 419 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 420 ;; class level
 421
 422 (defun ccide-class-comment ()
 423   "Add comment to start of current class definition"
 424   (interactive)
 425   (let ((class (c-get-class-at-point)))
 426     (if (not class)
 427         (error "No class found")
 428       (goto-char (or (aref (car class) 3)
 429                      (aref (car class) 1)))
 430       (if (save-excursion
 431             (forward-line -1)
 432             (ccide-in-doxy-comment))
 433           (progn
 434             (search-backward "/**" nil t)
 435             (forward-char 4))
 436         (let ((indent (make-string (current-indentation) ? )))
 437           (insert "/** ")
 438           (save-excursion
 439             (insert "\n"
 440                     indent "    @short \n"
 441                     indent " */\n"
 442                     indent)))))))
 443
 444 (defun ccide-gen-class (name &optional defns)
 445   "Generate class declaration template"
 446   (interactive (list (read-string (concat "Class name (default "
 447                                           (ccide-file-name)
 448                                           "): ")
 449                                   nil nil (ccide-file-name))))
 450   (insert "class " name)
 451   (indent-according-to-mode)
 452   (let ((in (make-string c-basic-offset ? ))
 453         (ofs (make-string (current-indentation) ? )))
 454     (save-excursion
 455       (beginning-of-line)
 456       (open-line 1)
 457       (insert ofs "/** \\brief\n"
 458               ofs "  */"))
 459     (insert "\n" ofs)
 460     (save-excursion
 461       (insert "{\n"
 462               ofs "public:\n"
 463               ofs in "///////////////////////////////////////////////////////////////////////////\n"
 464               ofs in "// Types\n\n"
 465               ofs in "///////////////////////////////////////////////////////////////////////////\n"
 466               ofs in "///\\name Structors and default members\n"
 467               ofs in "///@{\n\n"
 468               ofs in "// default default constructor\n"
 469               ofs in "// default copy constructor\n"
 470               ofs in "// default copy assignment\n"
 471               ofs in "// default destructor\n\n"
 472               ofs in "// no conversion constructors\n\n"
 473               ofs in "///@}\n"
 474               ofs in "///////////////////////////////////////////////////////////////////////////\n"
 475               ofs in "///\\name Accessors\n"
 476               ofs in "///@{\n\n"
 477               ofs in "///@}\n"
 478               ofs in "///////////////////////////////////////////////////////////////////////////\n"
 479               ofs in "///\\name Mutators\n"
 480               ofs in "///@{\n\n"
 481               ofs in "///@}\n\n")
 482       (loop for defn in defns
 483             do (insert ofs in defn ";\n"))
 484       (if defns
 485           (insert "\n"))
 486       (insert ofs "protected:\n\n"
 487               ofs "private:\n\n"
 488               ofs "};\n"))))
 489
 490 (defun ccide-gen-class-defaults ()
 491   "Generate signatures of the default functions: default constructor,
 492 copy constructor, assignment operator and destructor."
 493   (indent-according-to-mode)
 494   (let* ((name (c-scope-name (aref (car (c-get-class-at-point)) 1)))
 495          (in (make-string c-basic-offset ? ))
 496          (ofs (make-string (current-indentation) ? ))
 497          (tspec (if ccide-gen-throw (concat "\n" ofs in "throw_(());\n") ";\n"))
 498          (colon 0))
 499     (while (string-match "::" name colon)
 500       (setq colon (match-end 0)))
 501     (setq name (substring name colon))
 502     (beginning-of-line)
 503     (delete-horizontal-space)
 504     (loop with exit = nil
 505           do (message (concat "1-dflt constr, 2-destr, "
 506                               "3-copy constr, 4-copy assmnt, "
 507                               "c-all copy, d-all dflt, RET-all/done: "))
 508           for ch = (read-event)
 509           for first = t then nil
 510           do (cond ((eq ch 'return)
 511                     (if first
 512                         (insert ofs name "()"
 513                                 tspec
 514                                 ofs name "(const " name "& other)"
 515                                 tspec
 516                                 ofs "~" name "();\n"
 517                                 ofs name "& operator=(const " name "& other)"
 518                                 tspec))
 519                     (setq exit t))
 520                    ((eq ch ?1)
 521                     (insert ofs name "()"
 522                             tspec))
 523                    ((eq ch ?2)
 524                     (insert ofs "~" name "();\n"))
 525                    ((eq ch ?3)
 526                     (insert ofs name "(const " name "& other)"
 527                             tspec))
 528                    ((eq ch ?4)
 529                     (insert ofs name "& operator=(const " name "& other)"
 530                             tspec))
 531                    ((eq ch ?c)
 532                     (insert ofs name "(const " name "& other)"
 533                             tspec
 534                             ofs name "& operator=(const " name "& other)"
 535                             tspec))
 536                    ((eq ch ?d)
 537                     (insert ofs name "()"
 538                             tspec
 539                             ofs "~" name "();\n"))
 540                    (t (setq unread-command-events (cons ch unread-command-events))
 541                       (setq exit t)))
 542           while (not exit))))
 543
 544 (defun ccide-gen-class-defaults-impl ()
 545   "Generate default implementations for class default functions"
 546   (interactive)
 547   (let ((defn (c-build-default-funcions-impl)))
 548     (kill-new (cadr defn))
 549     (message (concat (car defn) " default members"))))
 550
 551 (defun ccide-set-class-defaults-comment (word)
 552   (save-excursion
 553     (back-to-indentation)
 554     (if (not (looking-at ccide-class-defaults-word))
 555         (message "Not at class defaults commnet")
 556       (replace-match word t t nil 1))))
 557
 558 (defmacro ccide-build-class-defaults-f (sym)
 559   (let ((fn (intern (concat "ccide-set-class-defaults-"
 560                             (symbol-name sym)))))
 561     `(defun ,fn ()
 562        (interactive)
 563        (ccide-set-class-defaults-comment ,(symbol-name sym)))))
 564
 565 (ccide-build-class-defaults-f no)
 566 (ccide-build-class-defaults-f default)
 567 (ccide-build-class-defaults-f my)
 568 (ccide-build-class-defaults-f protected)
 569 (ccide-build-class-defaults-f private)
 570 (ccide-build-class-defaults-f disabled)
 571
 572 (defun ccide-gen-struct-constructors ()
 573   (save-excursion
 574     (beginning-of-line)
 575     (open-line 1)
 576     (indent-according-to-mode)
 577     (let* ((scope (c-get-block-scope))
 578            (class (c-parse-class scope))
 579            (variables (c-get-variable-members-with-type class))
 580            (name (c-scope-name (aref (car (last scope)) 1)))
 581            (in (make-string (current-indentation) ? ))
 582            (inin (make-string (+ (current-indentation) c-basic-offset) ? )))
 583       (insert name "()\n" inin ": ")
 584       (indent-according-to-mode)
 585       (loop for var in variables
 586             for first = t then nil
 587             if (not first) do (insert ", ")
 588             do (insert (car var) "()"))
 589       (insert "\n" in "{}\n"
 590               in name "(")
 591       (loop for var in variables
 592             for first = t then nil
 593             if (not first) do (insert ", ")
 594             do (insert (cdr var) " " (car var) "_"))
 595       (insert ")\n" inin ": ")
 596       (loop for var in variables
 597             for first = t then nil
 598             if (not first) do (insert ", ")
 599             do (insert (car var) "(" (car var) "_)"))
 600       (insert "\n" in "{}"))))
 601
 602 (defun ccide-class-impl-comment ()
 603   "Get implementation comment for current class"
 604   (interactive)
 605   (let* ((scope (c-get-block-scope))
 606          (name (c-get-full-prefix scope)))
 607     (kill-new (concat (make-string 75 ?/) "\n"
 608                       "// " name "\n\n"
 609                       "// protected\n\n"
 610                       "// private\n\n"))
 611     (message name)))
 612
 613 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 614 ;; function/method level
 615
 616 (defun ccide-function-comment ()
 617   "Add comment to start of current function"
 618   (interactive)
 619   (c-forward-out-of-comment)
 620   (let ((defun (c-get-defun-state))
 621         place indent)
 622     (c-goto-beginning-of-defun defun)
 623     (setq indent (make-string (current-indentation) ? ))
 624     (if (save-excursion
 625           (forward-line -1)
 626           (ccide-in-doxy-comment))
 627         ()
 628       (insert "/** ")
 629       (setq place (point))
 630       (insert "\n\n"
 631               indent "    @li @em PRE : \n"
 632               indent "    @li @em POST : \n\n"
 633               indent "    @short \n"
 634               indent " */\n" indent)
 635       (setq defun (c-get-defun-state)))
 636     (ccide-function-comment-adjust defun indent)
 637     (if place (goto-char place))))
 638
 639 (defun ccide-function-comment-grab-args ()
 640   (let ((limit (save-excursion
 641                  (search-backward "/**" nil t)
 642                  (point)))
 643         (end (progn (forward-line -1) (point)))
 644         begin start args argend)
 645     (if (search-backward "@throws" limit t)
 646         (setq argend (progn (beginning-of-line) (point)))
 647       (setq argend end))
 648     (while (or (search-backward "@param" limit t)
 649                (search-backward "@return" limit t)))
 650     (beginning-of-line)
 651     (setq start (point))
 652     (setq begin start)
 653     (while (search-forward "@param" argend t)
 654       (or (search-forward "@param" argend t)
 655           (search-forward "@return" argend t)
 656           (search-forward "@throws" argend t)
 657           (goto-char argend))
 658       (beginning-of-line)
 659       (setq args (cons (ccide-function-comment-parse-arg start (point))
 660                        args))
 661       (setq start (point)))
 662     (prog1
 663         (if (not (search-forward "@return" argend t))
 664             (cons nil args)
 665           (beginning-of-line)
 666           (cons (buffer-substring (point) argend) args))
 667       (delete-region begin end))))
 668
 669 (defun ccide-function-comment-parse-arg (start end)
 670   (save-excursion
 671     (goto-char start)
 672     (re-search-forward "@param\\s-*\\(\\S-*\\)" end t)
 673     (cons (match-string 1)
 674           (cons (buffer-substring start (match-beginning 1))
 675                 (buffer-substring (match-end 1) end)))))
 676
 677 (defun ccide-function-comment-get-throws (defun)
 678   (if (aref defun 4)
 679       (save-excursion
 680         (goto-char (car (aref defun 4)))
 681         (if (re-search-forward "\\(throw_\\|throw\\)((?\\s-*\\([^()]*\\))?)"
 682                                (cdr (aref defun 4)) t)
 683             (let ((spec (match-string 2)))
 684               (if (> (length spec) 0)
 685                   spec))))))
 686
 687 (defun ccide-function-comment-adjust (defun indent)
 688   (let* ((defargs (mapcar (function (lambda (x)
 689                                       (c-get-template-argument-name (car x) (cdr x))))
 690                           (aref defun 3)))
 691          (defret (and (aref defun 1)
 692                       (not (string-match (concat "^\\("
 693                                                  c-special-key
 694                                                  "\\s-*\\)*\\s-*void$")
 695                                          (buffer-substring (car (aref defun 1))
 696                                                            (cdr (aref defun 1)))))))
 697          (throws (ccide-function-comment-get-throws defun))
 698          (xargs (ccide-function-comment-grab-args))
 699          (docargs (cdr xargs))
 700          (docret (car xargs))
 701          (def-in-doc (loop for defarg in defargs always (assoc defarg docargs)))
 702          (doc-in-def (loop for docarg in docargs always (member (car docarg) defargs)))
 703          (size-eq (= (length defargs) (length docargs))))
 704     (if (or defargs defret throws)
 705         (if (not (save-excursion
 706                    (forward-line -1)
 707                    (looking-at "\\s-*$")))
 708             (insert "\n")))
 709     ;; We differentiate four types changes
 710     ;;  - new arguments
 711     ;;  - removed arguments
 712     ;;  - reordered arguments
 713     ;;  - renamed arguments
 714     ;;
 715     ;; If the change cannot be described by one of the above, it has
 716     ;; to be resolved manually
 717     (save-excursion
 718       (cond (doc-in-def
 719              ;; reordered arguments or new arguments (or no change)
 720              (loop for defarg in defargs
 721                    for docarg = (assoc defarg docargs)
 722                    do (if docarg
 723                           (insert (cadr docarg) (car docarg) (cddr docarg))
 724                         (insert indent "    @param " defarg " \n"))))
 725             (size-eq ; and (not doc-in-def)
 726              ;; renamed arguments
 727              (loop for defarg in defargs
 728                    for docarg in docargs
 729                    do (insert (cadr docarg) defarg (cddr docarg))))
 730             (def-in-doc
 731               ;; removed arguments
 732               (loop for defarg in defargs
 733                     for docarg = (assoc defarg docargs)
 734                     do (insert (cadr docarg) (car docarg) (cddr docarg))))
 735             (t (error "Arg change too complex. Resolve manualy.")))
 736       ;; return value is simple
 737       (if defret
 738           (if docret
 739               (insert docret)
 740             (insert indent "    @return \n")))
 741       (if throws
 742           (insert indent "    @throws " throws "\n")))
 743     (back-to-indentation)))
 744
 745 (defun ccide-grab-prototype (&optional prefix)
 746   "Grab prototype of function defined or declared at point. Prefix
 747 arg, if given, specifies the kind of prefix (inline, static, ...) to use."
 748   (interactive "P")
 749   (let* ((prfx (or (and prefix (nth (prefix-numeric-value prefix) c-user-prefixes))
 750                    ccide-default-prefix))
 751          (defn (c-build-defun prfx)))
 752     (kill-new (concat (cadr defn) "\n{}\n"))
 753     (message (concat (or prfx "")
 754                      (if prfx " " "")
 755                      (car defn)))))
 756
 757 (defun ccide-reformat-defun ()
 758   "Reformat the defn of the current defun."
 759   (interactive)
 760   (save-excursion
 761     (c-beginning-of-defun-or-decl)
 762     (let ((defn (c-build-defun nil t)))
 763       (delete-region (or (caar (aref (caddr defn) 0))
 764                          (car (aref (caddr defn) 1))
 765                          (car (aref (caddr defn) 2)))
 766                      (or (car (aref (caddr defn) 6))
 767                          (aref (caddr defn) 7)))
 768       (insert (cadr defn) "\n"))))
 769
 770 (defun ccide-replace-defun ()
 771   "Replace the function header with the one on the top of the kill
 772 ring (presumably placed there using c++-grab-prototype)."
 773   (interactive)
 774   (save-excursion
 775     (c-beginning-of-defun-or-decl)
 776     (let ((parse (c-parse-defun)))
 777       (delete-region (or (aref parse 0)
 778                          (aref parse 1)
 779                          (aref parse 2))
 780                      (or (aref parse 5)
 781                          (aref parse 6)))
 782       (yank)
 783       (delete-char -3))))
 784
 785 (defun ccide-prefix-defun-type-with-class (&optional strip)
 786   "If a non-keyword type symbol is found prefixing the current defun,
 787 it will be prefixed with the current class prefix."
 788   (interactive "p")
 789   (save-excursion
 790     (c-beginning-of-defun-or-decl)
 791     (let* ((parse (c-parse-defun))
 792            (prefix (c-scope-name (aref parse 2) (+ (or strip 0) 0))))
 793       (goto-char (aref parse 1))
 794       (while (and (or (looking-at c-any-key)
 795                       (looking-at c-user-prefix-re)
 796                       (not (c-at-symbol-p)))
 797                   (< (point) (aref parse 2))
 798                   (not (eobp)))
 799         (c-forward-token-1)
 800         (c-forward-syntactic-ws))
 801       (if (and (c-at-symbol-p)
 802                (< (point) (aref parse 2))
 803                (not (looking-at (regexp-quote prefix))))
 804           (let ((pos (string-match "<" prefix)))
 805             (if pos
 806                 (insert "typename "))
 807             (if (and pos (looking-at (concat (substring prefix 0 pos)
 808                                              "\\b[^_]")))
 809                 (progn
 810                   (goto-char (match-end 0))
 811                   (c-backward-syntactic-ws)
 812                   (insert (substring prefix pos)))
 813               (insert prefix "::"))
 814             (ccide-reformat-defun))))))
 815
 816 (defun ccide-prefix-defun-type-with-namespace (&optional strip)
 817   (interactive "p")
 818   (ccide-prefix-defun-type-with-class (+ (or strip 0) 1)))
 819
 820 (defun ccide-insert-defun-prefix (&optional strip)
 821   "Insert the current defun prefix at point."
 822   (interactive "p")
 823   (let* ((parse (c-parse-defun))
 824          (prefix (c-scope-name (aref parse 2) (+ (or strip 0) 0))))
 825     (insert prefix "::")))
 826
 827 (defun ccide-kill-inline-decl (defn)
 828   (save-excursion
 829     (if (aref (caddr defn) 6)
 830         (progn
 831           (goto-char (cdr (aref (caddr defn) 6)))
 832           (let ((end-mark (point-marker)))
 833             (goto-char (car (aref (caddr defn) 6)))
 834             (indent-rigidly (point) end-mark
 835                             (- (current-column)))
 836             (prog1
 837                 (concat (cadr defn)
 838                         "\n"
 839                         (buffer-substring-no-properties (point) end-mark)
 840                         "\n")
 841               (when (aref (caddr defn) 5)
 842                 (goto-char (caar (aref (caddr defn) 5)))
 843                 (c-backward-syntactic-ws)
 844                 (skip-chars-backward ":"))
 845               (c-backward-syntactic-ws)
 846               (delete-region (point) end-mark)
 847               (insert ";"))))
 848       (concat (cadr defn) "\n{}\n"))))
 849
 850 (defun ccide-grab-inline-decl ()
 851   "Grab the inline decl at point at turn it into an out-of-line inline
 852 declaration at the top of the kill ring."
 853   (interactive)
 854   (let ((defn (c-build-defun (or ccide-default-prefix "inline"))))
 855     (kill-new (ccide-kill-inline-decl defn))
 856     (message (concat (or ccide-default-prefix "indline")
 857                      " "
 858                      (car defn)))))
 859
 860 (defun ccide-grab-all-inlines ()
 861   "Grab all inline decls in the current class"
 862   (interactive)
 863   (let ((class (c-parse-class (c-get-block-scope)))
 864         defns)
 865     (when class
 866       (loop for method in (nreverse (aref class 4))
 867             do (when (eq (car method) 'method)
 868                  (let ((defn (save-excursion
 869                                (goto-char (cdr method))
 870                                (c-build-defun (or ccide-default-prefix "inline")))))
 871                    (if (aref (caddr defn) 6)
 872                        (setq defns (nconc defns (list (ccide-kill-inline-decl defn))))))))
 873       (kill-new (loop for defn in (nreverse defns)
 874                       for next = nil then t
 875                       if next concat "\n";
 876                       concat defn))
 877       (message (format "%d inlines grabed to kill ring" (length defns))))))
 878
 879
 880 (defun ccide-grab-create-constructor ()
 881   (interactive)
 882   (let ((defn (c-build-create-constructor)))
 883     (kill-new (cadr defn))
 884     (message (car defn))))
 885
 886 (defun ccide-grab-create-constructor-impl (&optional prefix)
 887   (interactive "P")
 888   (let* ((prfx (or (and prefix (nth (prefix-numeric-value prefix) c-user-prefixes))
 889                    ccide-default-prefix))
 890          (defn (c-build-create-constructor-impl prfx)))
 891     (kill-new (cadr defn))
 892     (message (concat (or prfx "")
 893                      (if prfx " " "")
 894                      (car defn)))))
 895
 896 ;; (defun ccide-find-implementation (&optional other-window)
 897 ;;   "Find implementation of method declared at point."
 898 ;;   (interactive "P")
 899 ;;   (let ((def (c-build-defun))
 900 ;;      match pos)
 901 ;;     (setq match (concat (regexp-quote (car def)) "[ \t\n\r]*("))
 902 ;;     (setq match (string-replace "::" "::[ \t\n\r]*" match t nil t t))
 903 ;;     (message match)
 904 ;;     (loop for ext in ccide-implementation-extensions
 905 ;;        do (let* ((filename (ccide-file-name ext))
 906 ;;                  (buf (and (file-readable-p filename) (find-file-noselect filename))))
 907 ;;             (if buf
 908 ;;                 (save-excursion
 909 ;;                   (set-buffer buf)
 910 ;;                   (goto-char (point-min))
 911 ;;                   (if (loop while (search-forward-regexp match nil t)
 912 ;;                             do (forward-char -1)
 913 ;;                             thereis (c-at-toplevel-p))
 914 ;;                       (setq pos (cons buf (point)))))))
 915 ;;        until pos)
 916 ;;     (if pos
 917 ;;      (let ((win (get-buffer-window (car pos))))
 918 ;;           (if win
 919 ;;               (select-window win)
 920 ;;             (if other-window
 921 ;;                 (switch-to-buffer-other-window (car pos))
 922 ;;               (switch-to-buffer (car pos))))
 923 ;;        (goto-char (cdr pos))
 924 ;;        (forward-char -1)
 925 ;;        (c-beginning-of-defun-or-decl))
 926 ;;       (message (concat "Implementation of " (car def) " not found.")))))
 927
 928 (defun ccide-find-implementation (&optional other-window)
 929   "Find implementation of method declared at point."
 930   (interactive "P")
 931   (let* ((state (c-get-defun-state))
 932          (name (c-defun-short-name state))
 933          (scoped-name (c-defun-full-name state))
 934          (args (ccide-implementation-args state))
 935          (targs (ccide-implementation-template-args state))
 936          rv fallback)
 937
 938     (loop for ext in ccide-implementation-extensions
 939           for filename = (ccide-file-name ext)
 940           while (not rv)
 941           do (progn
 942                (let ((buf (or (find-buffer-visiting filename)
 943                                   (and (file-readable-p filename)
 944                                        (find-file-noselect filename)))))
 945                  (when buf
 946                    (let ((found (save-excursion
 947                                   (set-buffer buf)
 948                                   (ccide-find-implementation-1 name scoped-name args targs
 949                                                                (not (aref state 6))
 950                                                                (car (aref state 2))))))
 951                      (if found
 952                          (if (cdr found)
 953                              (setq rv (cons buf found))
 954                            (if (not fallback) (setq fallback (cons buf found))))))))))
 955     (if (not rv) (setq rv fallback))
 956     (if rv
 957         (let* ((buf (car rv))
 958                (pos (cadr rv))
 959                (win (get-buffer-window buf)))
 960           (if win
 961               (select-window win)
 962             (if other-window
 963                 (switch-to-buffer-other-window buf)
 964               (switch-to-buffer buf)))
 965           (goto-char pos)
 966           (forward-char -1)
 967           (c-beginning-of-defun-or-decl))
 968       (message (concat "Implementation of " scoped-name " not found.")))))
 969
 970 (defun ccide-implementation-args (state)
 971   (string-replace "[ \t\n\r]+" ""
 972                   (loop for (start . end) in (aref state 3)
 973                         for sep = "" then ","
 974                         concat sep
 975                         concat (buffer-substring-no-properties
 976                                 start (save-excursion
 977                                         (goto-char start)
 978                                         (if (search-forward "=" end 'move) (forward-char -1))
 979                                         (point))))
 980
 981                   t))
 982
 983 (defun ccide-implementation-template-args (state)
 984   (and (aref state 0)
 985        (string-replace "[ \t\n\r]+" ""
 986                        (loop for (start . end) in   (save-excursion
 987                                                       (goto-char (caar (last (aref state 0))))
 988                                                       (c-parse-template-declaration))
 989                              for sep = "" then ","
 990                              concat sep
 991                              concat (buffer-substring-no-properties
 992                                      start (save-excursion
 993                                              (goto-char start)
 994                                              (if (search-forward "=" end 'move) (forward-char -1))
 995                                              (point))))
 996                        t)))
 997
 998 (defun ccide-find-implementation-1 (name scoped-name args targs with-body skip-def)
 999   ;; Within the current buffer, search for all implementations of the
1000   ;; given function. The rv is a list of conses. The car holds the
1001   ;; buffer position of the implementation, the cdr is t if the name,
1002   ;; scoped-name and args are matched, otherwise the args did not match.
1003   (save-excursion
1004     (goto-char (point-min))
1005     (let ((re (concat (if (eq (char-syntax (aref name 0)) ?w) "\\<" "")
1006                       (regexp-quote name)
1007                       (if (eq (char-syntax (aref name (1- (length name)))) ?w) "\\>" "")))
1008           fallback rv check-state)
1009       (while (and (not rv) (re-search-forward re nil t))
1010         (if (and (c-at-toplevel-p)
1011                  (not (c-in-literal))
1012                  (setq check-state (condition-case nil (c-get-defun-state) (error nil)))
1013                  (not (= (car (aref check-state 2)) skip-def)))
1014             (if (string= scoped-name (c-defun-full-name check-state))
1015                 (if (and (if with-body (aref check-state 6) (not (aref check-state 6)))
1016                          (string= args (ccide-implementation-args check-state))
1017                          (string= targs (ccide-implementation-template-args check-state)))
1018                     (setq rv (cons (point) t))
1019                   (if (not fallback)
1020                       (setq fallback (cons (point) nil)))))))
1021       (or rv fallback))))
1022
1023 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1024 ;; variable/type level
1025
1026 (defun ccide-variable-comment ()
1027   "Add a comment to current variable declaration."
1028   (interactive)
1029   (push-mark)
1030   (beginning-of-line)
1031   (open-line 1)
1032   (insert "/// ")
1033   (indent-according-to-mode))
1034
1035 (defun ccide-grab-access-fn ()
1036   (interactive)
1037   (save-excursion
1038     (beginning-of-line)
1039     (if (looking-at (concat c++-simple-type-regexp "[ \t\n\r][a-zA-Z0-9_]+[ \t\n\r]*;"))
1040         (let ((vardef (match-string 0))
1041               (in (make-string c-basic-offset ? ))
1042               type varname ws doc)
1043           (forward-line -1)
1044           (back-to-indentation)
1045           (if (looking-at "///[ \t\n\r]*")
1046               (setq doc (buffer-substring (match-end 0)
1047                                           (progn (end-of-line) (point)))))
1048           (string-match "^[ \t\n\r]*\\(.*\\)[ \t\n\r]\\([a-zA-Z0-9_]+\\)[ \t\n\r]*;$"
1049                         vardef)
1050           (setq varname (match-string 2 vardef)
1051                 type (match-string 1 vardef)
1052                 ws (substring vardef 0 (match-beginning 1)))
1053           (if (string-match "^[ \t\n\r]*" type)
1054               (setq type (substring type (match-end 0))))
1055           (kill-new (concat (if doc
1056                                 (concat ws "/** Setze " doc ".\n\n"
1057                                         ws "    @param _" varname " neu: " doc "\n"
1058                                         ws "    @return alt: " doc "\n"
1059                                         ws " */\n")
1060                               "")
1061                             ws type " q_" varname "(" type " _" varname ")\n"
1062                             ws in "{\n"
1063                             ws in in type " old" varname " = " varname ";\n"
1064                             ws in in varname " = _" varname ";\n"
1065                             ws in in "return(old" varname ");\n"
1066                             ws in "}\n\n"
1067                             (if doc
1068                                 (concat ws "/** Hole " doc ".\n\n"
1069                                         ws "    @return " doc "\n"
1070                                         ws "*/\n")
1071                               "")
1072                             ws type " q_" varname "(void) const\n"
1073                             ws in "{ return(" varname "); }\n"))
1074
1075           (message varname))
1076       (message "No variable found"))))
1077
1078 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1079 ;; doxy comment support functions
1080
1081 (defun ccide-special-indent-function ()
1082   "Function to indent doxy comments correctly"
1083   (let ((indent (ccide-in-doxy-comment)))
1084     (if indent
1085         (let ((lim (save-excursion
1086                      (back-to-indentation)
1087                      (c-literal-limits)))
1088               (pos (- (point-max) (point))))
1089           (save-excursion
1090             (back-to-indentation)
1091             (if (looking-at "*/")
1092                 (incf indent -3)
1093               (let ((para (or (save-excursion (re-search-backward "^\\s-*$" (car lim) t))
1094                               (car lim))))
1095                 (if (and (not (looking-at ccide-doxy-tag-re))
1096                          (re-search-backward (concat "^\\s-*"
1097                                                      ccide-doxy-tag-re)
1098                                              para t))
1099                     (incf indent 4)))))
1100           (delete-region (progn (beginning-of-line) (point))
1101                          (progn (back-to-indentation) (point)))
1102           (indent-to indent)
1103           (if (> (- (point-max) pos) (point))
1104               (goto-char (- (point-max) pos)))))))
1105
1106 (defun ccide-fill-function ()
1107   "auto-fill function for doxy comments"
1108   (if (do-auto-fill)
1109       (if (not fill-prefix)
1110           (indent-according-to-mode))))
1111
1112 (defun ccide-hide-all-doxy-comments ()
1113   "Hide all doxy comments"
1114   (interactive)
1115   (save-excursion
1116     (goto-char (point-min))
1117     (while (re-search-forward "^\\s-*/\\*\\*" nil t)
1118       (beginning-of-line)
1119       (forward-line -1)
1120       (if (not (looking-at "\\s-*$"))
1121           (forward-line 1))
1122       (forward-char -1)
1123       (let ((start (point)))
1124         (if (re-search-forward "\\*/" nil t)
1125             (progn
1126               (if (looking-at "\\s-*\n")
1127                   (forward-line 1))
1128               (forward-char -1)
1129               (let ((overlay (make-overlay start (point))))
1130                 (overlay-put overlay 'intangible 'hs)
1131                 (overlay-put overlay 'invisible 'hs)))))))
1132   (message "Done."))
1133
1134 (defun ccide-show-all-comments ()
1135   "Show all comments"
1136   (interactive)
1137   (save-excursion
1138     (goto-char (point-min))
1139     (while (not (eobp))
1140       (goto-char (next-overlay-change (point)))
1141       (loop for overlay in (overlays-at (point))
1142             if (eq (overlay-get overlay 'invisible) 'hs)
1143             do (delete-overlay overlay))))
1144   (message "Done."))
1145
1146
1147
1148 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1149 ;; CORBA support (omniORB2)
1150
1151 (defun ccide-get-corba-headers ()
1152   (let (files)
1153     (save-excursion
1154       (goto-char (point-min))
1155       (while (re-search-forward "#include\\s-*[\"<]\\([^\">]*\\)\\.hh[\">]" nil t)
1156         (setq files (cons (ccide-match-string 1) files)))
1157       (nreverse files))))
1158
1159 (defun ccide-corba-maybe-build-hh (file)
1160   (let ((skel (ccide-file-name ".hh" file ccide-corba-skel-dir))
1161         (idl (ccide-file-name ".idl" file ccide-corba-idl-dir)))
1162     (if (and (file-readable-p idl)
1163              (or (not (file-readable-p skel))
1164                  (file-newer-than-file-p idl skel)))
1165         (let ((buffer (find-buffer-visiting (ccide-file-name ".hh" file))))
1166           (if buffer
1167               (kill-buffer buffer))
1168           (message "Please wait ... building %s" (ccide-file-name ".hh" file))
1169           (if (ccide-shell-command (concat "cd "
1170                                            (real-path-name ccide-corba-skel-dir)
1171                                            " && "
1172                                            ccide-corba-idl-command
1173                                            (if (> (length ccide-corba-idl-dir) 0)
1174                                                (concat " -I" ccide-corba-idl-dir))
1175                                            " "
1176                                            idl))
1177               ()
1178             (display-buffer (get-buffer-create "*ccide shell command*"))
1179             (error "Generation of %s failed" (ccide-file-name ".hh")))))
1180     (if (not (file-readable-p skel))
1181         (error "No file %s or %s"
1182                (ccide-file-name ".hh" file) (ccide-file-name ".idl" file)))))
1183
1184 (defun ccide-corba-list-skeletons-1 (hh-file)
1185   (ccide-corba-maybe-build-hh hh-file)
1186   (let ((hh-buf (find-file-noselect (ccide-file-name ".hh" hh-file)))
1187         skels)
1188     (save-excursion
1189       (set-buffer hh-buf)
1190       (save-excursion
1191         (goto-char (point-min))
1192         (while (re-search-forward "^\\s-*class\\s-+_sk_\\([a-zA-Z0-9_]+\\)\\s-+:"
1193                                   nil t)
1194           (setq skels (cons (ccide-match-string 1) skels)))))
1195     (mapcar (function (lambda (x) (cons x hh-file)))
1196             (sort skels 'string-lessp))))
1197
1198 (defun ccide-corba-list-skeletons ()
1199   (let ((files (ccide-get-corba-headers)))
1200     (loop for file in files
1201           append (ccide-corba-list-skeletons-1 file))))
1202
1203 (defun ccide-gen-corba-impl (class)
1204   (interactive (list (completing-read "Class name of skeleton: "
1205                                       (ccide-corba-list-skeletons)
1206                                       nil t)))
1207   (let* ((skels (ccide-corba-list-skeletons))
1208          (hh-file (ccide-file-name ".hh" (cdr (assoc class skels))
1209                                    ccide-corba-skel-dir))
1210          (hh-buf (find-file-noselect (ccide-file-name ".hh" hh-file
1211                                                       ccide-corba-skel-dir))))
1212     (ccide-gen-class (concat class "_i"))
1213     (insert (make-string c-basic-offset ? ) ": public virtual _sk_" class "\n")
1214     (save-excursion
1215       (search-forward "protected:" nil t)
1216       (forward-line -1)
1217       (ccide-gen-corba-impl-methods)
1218       (insert "\n"))))
1219
1220 (defun ccide-get-corba-defns (hh-file class)
1221   (let ((hh-buf (find-file-noselect hh-file))
1222         defns)
1223     (save-excursion
1224       (set-buffer hh-buf)
1225       (save-excursion
1226         (goto-char (point-min))
1227         (if (not (re-search-forward (concat "^\\s-*class\\s-+_sk_" class "\\s-+:")
1228                                     nil t))
1229             (error "CORBA skeleton class not found.")
1230           (search-forward "{")
1231           (forward-char -1)
1232           (let ((end (save-excursion (forward-sexp) (point))))
1233             (while (and (< (point) end)
1234                         (< (forward-line 1) 1))
1235               (if (looking-at "\\s-+virtual\\s-+\\(.*)\\)\\s-*=\\s-*0;\\s-*$")
1236                   (setq defns (cons (match-string 1) defns))))))))
1237     (nreverse defns)))
1238
1239 (defun ccide-gen-corba-impl-methods ()
1240   (interactive)
1241   (let* ((class (c-get-class-at-point))
1242          (point (point)))
1243     (if (not class)
1244         (error "No class at point."))
1245     (save-excursion
1246       (goto-char (aref (car class) 1))
1247       (if (not (re-search-forward ":\\s-*public\\s-*virtual\\s-*_sk_\\([^ \t\n\r{},:]*\\)"
1248                                   nil t))
1249           (error "No CORBA impl at point."))
1250       (let* ((name (ccide-match-string 1))
1251              (skels (ccide-corba-list-skeletons))
1252              (hh-file (ccide-file-name ".hh" (cdr (assoc name skels))
1253                                        ccide-corba-skel-dir))
1254              (defns (ccide-get-corba-defns hh-file name))
1255              end)
1256         (goto-char (aref (car class) 2))
1257         (save-excursion
1258           (c-forward-sexp)
1259           (setq end (point)))
1260         (if (re-search-forward "^\\s-*// CORBA$" end t)
1261             (let ((start (match-beginning 0)))
1262               (if (re-search-forward "^\\s-*// END-CORBA$" end t)
1263                   (let ((eend (match-end 0)))
1264                     (goto-char start)
1265                     (forward-line 1)
1266                     (if (re-search-forward "/\\*\\|//" (match-beginning 0) t)
1267                         (if (y-or-n-p "Remove CORBA Funktion comments? (y/n)")
1268                             (delete-region start (1+ eend))
1269                           (goto-char eend)
1270                           (beginning-of-line)
1271                           (delete-region (point) (progn
1272                                                    (end-of-line)
1273                                                    (1+ (point))))
1274                           (save-excursion
1275                             (goto-char start)
1276                             (delete-region (point) (progn
1277                                                      (end-of-line)
1278                                                      (1+ (point)))))
1279                           (insert "\n"))
1280                       (delete-region start (1+ eend))))))
1281           (goto-char point))
1282         (indent-according-to-mode)
1283         (insert "// CORBA\n")
1284         (loop for defn in defns
1285               do (progn
1286                    (save-excursion (insert defn ";"))
1287                    (indent-according-to-mode)
1288                    (let ((start (point)) end)
1289                      (end-of-line)
1290                      (setq end (point))
1291                      (goto-char start)
1292                      (while (re-search-forward "\\s-+" end t)
1293                        (replace-match " ")
1294                        (setq end (- end (- (match-end 0) (match-beginning 0) 1))))
1295                      (end-of-line)
1296                      (loop with done = nil
1297                            while (> (current-column) c-max-def-column)
1298                            do (while (and (> (current-column) c-max-def-column)
1299                                           (search-backward "," start t)))
1300                            do (if (looking-at ",")
1301                                   (progn
1302                                     (forward-char 1)
1303                                     (insert "\n")
1304                                     (open-line 1)
1305                                     (indent-according-to-mode)
1306                                     (delete-char 2)
1307                                     (setq start (point))
1308                                     (end-of-line))
1309                                 (setq done t))
1310                            while (not done)))
1311                    (insert "\n")))
1312         (indent-according-to-mode)
1313         (insert "// END-CORBA\n")))))
1314
1315 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1316 ;; template support
1317
1318 (defun ccide-scan-mantemps ()
1319   "Scan *compilation* buffer for errors and generate manual template
1320 instatiations at point."
1321   (interactive)
1322   (save-excursion
1323     (set-buffer "*compilation*")
1324     (goto-char (point-min)))
1325   (save-excursion
1326     (set-buffer (get-buffer-create "*mantemps*"))
1327     (erase-buffer)
1328     (loop for temp = (ccide-get-mantemp)
1329           while temp
1330           do (insert temp "\n"))
1331     (mantemp-make-mantemps-buffer)
1332     (goto-char (point-min))
1333     (while (progn
1334              (ccide-fix-mantemp)
1335              (< (forward-line 1) 1))))
1336   (insert-buffer-substring "*mantemps*"))
1337
1338 (defun ccide-get-mantemp ()
1339   (save-excursion
1340     (set-buffer "*compilation*")
1341     (if (search-forward "undefined reference to `" nil t)
1342         (let ((start (point)))
1343           (end-of-line)
1344           (search-backward "'" nil t)
1345           (buffer-substring start (point))))))
1346
1347 (defun ccide-fix-mantemp ()
1348   (let ((end (save-excursion
1349                (end-of-line) (point))))
1350     (if (and (save-excursion (search-forward "(" end t))
1351              (search-forward " class" end t))
1352         (progn
1353           (forward-char -6)
1354           (delete-char 6)))))
1355
1356 (provide 'cc-ide)
1357
1358 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1359 ;; other stuff
1360
1361 (defun ccide-open-compilation-frame ()
1362   (interactive)
1363   (let ((c-frame (selected-frame))
1364         (compilation-frame (make-frame '((minibuffer . nil)
1365                                          (unsplittable . t)
1366                                          (menu-bar-lines . 0)
1367                                          (top . -87)
1368                                          (left . 36)
1369                                          (width . 169)
1370                                          (height . 9)))))
1371     (select-frame compilation-frame)
1372     (switch-to-buffer "*compilation*")
1373     (set-window-dedicated-p (selected-window) t)))
1374
1375 (defun ccide-compile (command)
1376   (delete-other-windows)
1377   (split-window-horizontally)
1378   (compile command)
1379   (save-excursion
1380     (set-buffer "*compilation*")
1381     (let ((point (point-max)))
1382       (goto-char point)
1383       (loop for window in (get-buffer-window-list "*compilation*" nil t)
1384             do (set-window-point window point)))))
1385
1386 (defun ccide-compile-compile ()
1387   (interactive)
1388   (ccide-compile (concat "make -k " ccide-compile-opts)))
1389
1390 (defun ccide-compile-clean ()
1391   (interactive)
1392   (ccide-compile (concat "make -k " ccide-compile-opts " clean")))
1393
1394 (defun ccide-compile-cleandepends ()
1395   (interactive)
1396   (ccide-compile (concat "make -k " ccide-compile-opts " cleandepends")))
1397
1398 (defun ccide-compile-kill ()
1399   (interactive)
1400   (set-buffer "*compilation*")
1401   (kill-compilation))
1402
1403 (defun ccide-hide-compilation ()
1404   (interactive)
1405   (let ((active (selected-window)))
1406     (unwind-protect
1407         (loop for window in (get-buffer-window-list "*compilation*")
1408               do (progn (select-window window)
1409                         (switch-to-buffer (other-buffer "*compilation*"))))
1410       (select-window active))))
1411
1412 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1413 ;; keymap and installation
1414
1415 (defun ccide-bind-keys (prefix map)
1416   (loop for binding in ccide-bindings
1417         do (apply 'vcmd-define-key
1418                   map
1419                   (concat prefix (car binding))
1420                   (cadr binding)
1421                   "IDE"
1422                   (cddr binding))))
1423
1424 (defun ccide-install-it ()
1425   (save-excursion
1426     (hs-minor-mode 1)
1427     (hs-show-all))
1428   (local-unset-key "\C-c;")
1429   (local-unset-key [menu-bar IDE])
1430   (ccide-bind-keys "\C-c;" (current-local-map))
1431   (local-set-key "\C-cC" 'ccide-hide-all-doxy-comments)
1432   (local-set-key "\C-cS" 'ccide-show-all-comments)
1433   (set (make-local-variable 'auto-fill-function) 'ccide-fill-function)
1434   (set (make-local-variable 'paragraph-start) (concat "[ \t\f]*$\\|[ \t\f]*" ccide-doxy-tag-re))
1435   (set (make-local-variable 'paragraph-separate) "[ \t\f]*$")
1436   (auto-fill-mode -1)
1437   (ccide-project-load-config)
1438   (ccide-auto-decorate-new-files))
1439
1440 (defun ccide-project-load-config ()
1441   (let ((conf (ccide-project-search-upwards "project.el" (file-name-directory (buffer-file-name)))))
1442     (when conf
1443       (set (make-local-variable 'ccide-project-root) (file-name-directory conf))
1444       (load-file conf))))
1445
1446 (defun ccide-project-search-upwards (file &optional dir)
1447   "Search for FILE in all directories starting at DIR and going up the directory hierarchy.
1448 DIR defaults to ccide-project-root"
1449   (let (conf last-dir)
1450     (setq dir (expand-file-name "x" (or dir ccide-project-root)))
1451     (while (and (not (string= (setq last-dir dir
1452                                     dir (directory-file-name (file-name-directory dir))) last-dir))
1453                 (setq conf (expand-file-name file dir))
1454                 (not (file-readable-p conf))))
1455     (and (file-readable-p conf) conf)))
1456
1457 (add-hook 'c-mode-hook 'ccide-install-it)
1458 (add-hook 'c++-mode-hook 'ccide-install-it)
1459 (add-hook 'c-special-indent-hook 'ccide-special-indent-function)
1460
1461 (loop for extension in ccide-special-extensions
1462       for re = (concat (regexp-quote extension) "$")
1463       if (not (assoc re auto-mode-alist))
1464         do (setq auto-mode-alist (append auto-mode-alist
1465                                          (list (cons re 'c++-mode)))))
1466
1467 (defadvice c-indent-line (after c-indent-less compile disable) ;activate
1468   ;; new indent function for c-mode: do standard indentation first. If line
1469   ;; is to long using standard indentation, just indent by c-basic-indentation.
1470   (let ((cc (save-excursion (end-of-line) (current-column)))
1471         indent)
1472     (if (> cc  85)
1473         (let ((pos (- (point-max) (point))))
1474           (beginning-of-line)
1475           (let ((point (point))
1476                 (line (1+ (count-lines 1 (point))))
1477                 indent)
1478             (c-beginning-of-statement-2)
1479             (if (and (not (c-crosses-statement-barrier-p (point) point))
1480                      (not (eq (+ (count-lines 1 (point))
1481                                  (if (bolp) 1 0))
1482                               line)))
1483                 (progn
1484                   (setq indent (+ (current-indentation) c-basic-offset))
1485                   (goto-char point)
1486                   (if (< indent (current-indentation))
1487                       (progn
1488                         (setq ad-return-value
1489                               (+ ad-return-value
1490                                  (- (current-indentation) indent)))
1491                         (delete-region (c-point 'bol) (c-point 'boi))
1492                         (indent-to indent))))))
1493           (if (< (point) (c-point 'boi))
1494               (back-to-indentation)
1495             (if (> (- (point-max) pos) (point))
1496                 (goto-char (- (point-max) pos))))))))
1497
1498
1499 \f
1500 ;;; Local Variables:
1501 ;;; elisp-project-autoload-file-name: "cc-autoload.el"
1502 ;;; End: