cc-ide/cc-engine-2.el

   1 ;;; cc-engine-2.el --- Extensuions to cc-engine.el
   2 ;;
   3 ;; $Id$
   4 ;;
   5 ;; Copyright (C) 2000 Stefan Bund
   6
   7 ;; cc-engine-2.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-engine-2.el is distributed in the hope that it will be useful,
  13 ;; but 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 (defconst c-template-arglist-syntax
  27   (let ((table (copy-syntax-table c-mode-syntax-table)))
  28     (modify-syntax-entry ?< "(" table)
  29     (modify-syntax-entry ?> ")" table)
  30     table))
  31
  32 (defconst c-any-key
  33   (eval-when-compile
  34     (concat (regexp-opt '("break" "continue" "do" "else" "for" "if"
  35                           "return" "switch" "while" "sizeof" "typedef"
  36                           "extern" "auto" "register" "static" "friend"
  37                           "volatile" "const" "restrict" "enum"
  38                           "struct" "union" "class" "char" "short"
  39                           "int" "long" "signed" "unsigned" "float"
  40                           "double" "void" "complex" "case" "goto"
  41                           "inline" "try" "catch" "throw" "inline_"
  42                           "throw_" "virtual" "new" "delete" "explicit"
  43                           "prefix_" "typename" "template") t)
  44             "\\b[^_]")))
  45
  46 (defconst c-blocking-key
  47   (eval-when-compile
  48     (concat (regexp-opt '("if" "while" "for" "switch")) "\\b[^_]")))
  49
  50 (defconst c-class-scope-key "\\(class\\|struct\\|union\\)\\b[^_]")
  51 (defconst c-namespace-scope-key "namespace\\b[^_]")
  52 (defconst c-scope-key "\\(class\\|struct\\|union\\|namespace\\)");\\b[^_]")
  53 (defconst c-struct-scope-key "struct\\b[^_]")
  54 (defconst c-template-key "template\\b[^_]")
  55 (defconst c-operator-key "operator\\b[^_]")
  56 (defconst c-operator-operators nil)
  57 (defconst c-typedef-key "typedef\\b[^_]")
  58 (defconst c-friend-key "friend\\b[^_]")
  59 (defconst c-access-key "\\(public\\|protected\\|private\\)\\s-*:")
  60 (defconst c-access-keys
  61   '(("public\\s-*:" . public)
  62     ("protected\\s-*:" . protected)
  63     ("private\\s-*:" . private)))
  64 (defconst c-inheritance-spec-key "\\(public\\|protected\\|private\\|virtual\\)\\b[^_]")
  65
  66 (let ((assable '("+" "-" "*" "/" "%" "^" "&" "|" "~" "!" "=" "<" ">" ">>" "<<"))
  67       (others '("&&" "||" "++" "--" "->*" "," "->" "[]" "()" "new" "new[]"
  68                 "delete" "delete[]" "bool")))
  69   (setq c-operator-operators
  70         (regexp-opt (nconc (mapcar (function (lambda (x) (concat x "=")))
  71                                    assable)
  72                            assable others) t)))
  73
  74 (defconst c-operator-word
  75   (concat "operator\\s-*" c-operator-operators))
  76
  77 (defconst c-skip-syntaxes '(?  ?. ?'))
  78
  79 ;;; Code:
  80
  81 (require 'cl)
  82 (require 'cc-engine)
  83 (require 'cc-langs)
  84 (require 'cc-defs)
  85
  86 (defmacro c-with-temporary-syntax-table (table &rest body)
  87   ;; evaluate BODY temporarily binding the syntax table to TABLE
  88   (let ((saved-syntax-table (make-symbol "saved-syntax-table")))
  89     `(let ((,saved-syntax-table (syntax-table)))
  90        (unwind-protect
  91            (progn
  92              (set-syntax-table ,table)
  93              ,@body)
  94          (set-syntax-table ,saved-syntax-table)))))
  95
  96 (def-edebug-spec c-with-temporary-syntax-table (sexp body))
  97 (put 'c-with-temporary-syntax-table 'lisp-indent-function 1)
  98
  99 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 100 ;; moving by syntactic entities
 101
 102 (defun c-skip-non-sexp-chars-forward ()
 103   ;; skip char's not considered part of sexps forward
 104   (c-forward-syntactic-ws)
 105   (while (and (not (eq (following-char) ?<))
 106               (memq (char-syntax (following-char)) c-skip-syntaxes)
 107               (not (eobp)))
 108     (forward-char 1)
 109     (c-forward-syntactic-ws)))
 110
 111 (defun c-skip-non-sexp-chars-backward ()
 112   ;; skip char's not considered part of sexps backward
 113   (c-backward-syntactic-ws)
 114   (while (and (not (eq (preceding-char) ?>))
 115               (memq (char-syntax (preceding-char)) c-skip-syntaxes)
 116               (not (bobp)))
 117     (forward-char -1)
 118     (c-backward-syntactic-ws)))
 119
 120 ;; support for teplate arglists
 121
 122 (defun c-forward-template-arglist ()
 123   ;; skip forward over the <> delimited template arglist at
 124   ;; point. This temporarily changes the syntax-table to include <> as
 125   ;; matching delimiters and uses c-forward-sexp
 126   (c-skip-non-sexp-chars-forward)
 127   (if (not (eq (following-char) ?<))
 128       (c-forward-sexp)
 129     (let ((level 1))
 130       (forward-char 1)
 131       (while (and (> level 0)
 132                   (re-search-forward "[[({<>]" nil t))
 133         (if (not (c-in-literal))
 134             (cond ((memq (preceding-char) '(?\[ ?\( ?{))
 135                    (up-list 1))
 136
 137                   ((eq (preceding-char) ?<)
 138                    (setq level (1+ level)))
 139
 140                   ((eq (preceding-char) ?>)
 141                    (setq level (1- level)))))))))
 142
 143 (defun c-backward-template-arglist ()
 144   ;; reverse of c-forward-template-arglist
 145   (c-skip-non-sexp-chars-backward)
 146   (if (not (eq (preceding-char) ?>))
 147       (c-backward-sexp)
 148     (let ((level 1))
 149       (forward-char -1)
 150       (while (and (> level 0)
 151                   (re-search-backward "[])}<>]" nil t))
 152         (if (not (c-in-literal))
 153             (cond ((memq (following-char) '(?\] ?\) ?}))
 154                    (up-list -1))
 155
 156                   ((eq (following-char) ?>)
 157                    (setq level (1+ level)))
 158
 159                   ((eq (following-char) ?<)
 160                    (setq level (1- level)))))))))
 161
 162 (defsubst c-at-symbol-p ()
 163   (memq (char-syntax (following-char)) '(?w ?_)))
 164
 165 (defsubst c-after-symbol-p ()
 166   (memq (char-syntax (preceding-char)) '(?w ?_)))
 167
 168 (defun c-forward-extended-sexp ()
 169   ;; Move forward one sexp. This function tries to correctly skip
 170   ;; template argument lists delimited by angle brackets.
 171   (c-skip-non-sexp-chars-forward)
 172   (if (and (eq (following-char) ?<)
 173            (condition-case nil
 174                (let ((start (point)))
 175                  (c-forward-template-arglist)
 176                  (if (or (not (eq (preceding-char) ?>))
 177                          (c-crosses-statement-barrier-p start (point)))
 178                      (progn (goto-char start) nil) t))
 179              (error nil)))
 180       nil
 181     (c-forward-sexp)))
 182
 183 (defun c-backward-extended-sexp ()
 184   ;; reverse of c-forward-extenden-sexp
 185   (c-skip-non-sexp-chars-backward)
 186   (if (and (eq (preceding-char) ?>)
 187            (condition-case nil
 188                (let ((start (point)))
 189                  (c-backward-template-arglist)
 190                  (if (or (not (eq (following-char) ?<))
 191                          (c-crosses-statement-barrier-p (point) start))
 192                      (progn (goto-char start) nil) t))
 193              (error nil)))
 194       nil
 195     (c-backward-sexp)))
 196
 197 ;; names
 198
 199 (defun c-forward-scoped-name ()
 200   ;; skip forward over a possibly fully scoped name at point
 201   ;; optionally containing template arglists. return list of scope
 202   ;; separators in the name
 203   (c-forward-syntactic-ws)
 204   (let (points)
 205     (while
 206         (progn
 207           (setq points (cons (point) points))
 208           (if (looking-at "::")
 209               (forward-char 2))
 210           (c-forward-syntactic-ws)
 211           (if (and (cond ((looking-at c-operator-word)
 212                           (goto-char (match-end 0)))
 213                          ((looking-at "~")
 214                           (forward-char 1)
 215                           (prog1
 216                               (c-at-symbol-p)
 217                             (c-forward-token-1)))
 218                          (t
 219                           (prog1
 220                               (c-at-symbol-p)
 221                             (c-forward-token-1))))
 222                    (eq (following-char) ?<))
 223               (progn
 224                 (c-forward-template-arglist)
 225                 (c-forward-syntactic-ws)))
 226           (looking-at "::")))
 227     (nreverse points)))
 228
 229 (defun c-backward-scoped-name ()
 230   ;; reverse of c-forward-scoped-name
 231   (c-backward-syntactic-ws)
 232   (while
 233       (progn
 234         (if (and (eq (preceding-char) ?>)
 235                  (not (save-excursion
 236                         (re-search-backward (concat c-operator-word "\\=") nil t))))
 237             (c-backward-template-arglist))
 238         (c-backward-syntactic-ws)
 239         (if (re-search-backward (concat c-operator-word "\\=") nil t)
 240             (goto-char (match-beginning 0))
 241           (c-backward-token-1)
 242           (if (and (c-at-symbol-p)
 243                    (eq (preceding-char) ?~))
 244               (forward-char -1)))
 245         (c-backward-syntactic-ws)
 246         (if (eq (preceding-char) ?:)
 247             (progn
 248               (forward-char -1)
 249               (if (eq (preceding-char) ?:)
 250                   (progn
 251                     (forward-char -1)
 252                     (c-backward-syntactic-ws)
 253                     t)
 254                 (forward-char 1)
 255                 nil)))))
 256   (c-forward-syntactic-ws))
 257
 258 (defun c-forward-balanced-token ()
 259   (c-forward-syntactic-ws)
 260   (cond ((or (c-at-symbol-p)
 261              (looking-at c-operator-word))
 262          (c-forward-scoped-name))
 263         ((memq (following-char) '(?\( ?{ ?<))
 264          (c-forward-extended-sexp))
 265         (t
 266          (c-forward-token-1))))
 267
 268 (defun c-backward-balanced-token ()
 269   (c-backward-syntactic-ws)
 270   (cond ((or (c-after-symbol-p)
 271              (re-search-backward (concat c-operator-word "\\=") nil t))
 272          (c-backward-scoped-name))
 273         ((memq (preceding-char) '(?\) ?} ?>))
 274          (c-backward-extended-sexp))
 275         (t
 276          (c-backward-token-1))))
 277
 278 ;; defun's
 279
 280 (defun c-move-to-start-of-defun (&optional limit)
 281   ;; move point to start of current defun. point is left at the start
 282   ;; of the function's name. Use (c-beginning-of-statement-1) to get
 283   ;; to the start of the declaration. returns point of body's opening
 284   ;; brace if defun found, otherwise nil. if LIMIT is non-nil, don't
 285   ;; move farther back than that.
 286   (let (new-point brace-point)
 287     (save-excursion
 288       (while
 289           (and (c-save-uplist -1)
 290                (or (not limit)
 291                    (> (point) limit))
 292                (not (setq new-point
 293                           (if (and (eq (following-char) ?{)
 294                                    (c-just-after-func-arglist-p))
 295                               (progn
 296                                 (setq brace-point (point))
 297                                 (c-beginning-of-statement-1)
 298                                 (while (and (< (point) brace-point)
 299                                             (not (eq (following-char) ?\()))
 300                                   (c-forward-extended-sexp)
 301                                   (c-forward-syntactic-ws))
 302                                 (if (eq (following-char) ?\()
 303                                     (progn
 304                                       (c-backward-syntactic-ws)
 305                                       (c-backward-scoped-name)
 306                                       (if (not (looking-at c-conditional-key))
 307                                           (point)))))))))))
 308     (if new-point
 309         (goto-char new-point))
 310     (and new-point brace-point)))
 311
 312 (defun c-beginning-of-defun-or-decl ()
 313   (if (c-in-literal)
 314       (goto-char (car (c-literal-limits))))
 315   (while (and (not (c-at-toplevel-p))
 316               (c-save-uplist -1)))
 317   (c-move-to-start-of-defun)
 318   (let ((point (point)) beg)
 319     (c-beginning-of-statement-1)
 320     (setq beg (point))
 321     (c-end-of-statement)
 322     (if (> (point) point)
 323         (goto-char beg)
 324       (goto-char point))
 325     (c-forward-syntactic-ws)))
 326
 327 (defun c-forward-out-of-comment ()
 328   (while (memq (c-in-literal) '(c c++))
 329     (forward-char 1)))
 330
 331 (defun c-beginning-of-statement-2 ()
 332   ;; Move to the REAL beginning of the statement, ignoring all subexpressions
 333   (let ((point (point))
 334         (state (c-parse-state))
 335         (last (point)))
 336     (while (and state
 337                 (not (consp (car state)))
 338                 (progn
 339                   (goto-char (car state))
 340                   (looking-at "(")))
 341       (setq last (car state)
 342             state (cdr state)))
 343     (if (and state last
 344              (not (consp (car state))))
 345         (goto-char last))
 346     (c-beginning-of-statement-1)
 347     (while (and (< (point) point)
 348                 (or (c-crosses-statement-barrier-p (point) point)
 349                     (not (equal (c-parse-state) state))))
 350       (c-end-of-statement))
 351     (c-forward-syntactic-ws)
 352     (while (looking-at c-any-key)
 353       (if (looking-at c-blocking-key)
 354           (progn
 355             (c-forward-token-1)
 356             (c-forward-sexp))
 357         (c-forward-token-1))
 358       (c-forward-syntactic-ws))))
 359
 360 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 361 ;; information on scopes (nesting levels)
 362
 363 (defun c-aggressive-search-uplist-for-classkey ()
 364   ;; like search-uplist-for-classkey but agressively retry at all
 365   ;; scoping levels until classkey found
 366   (save-excursion
 367     (let (state)
 368       (loop for state = (c-parse-state)
 369             while state
 370             thereis (loop for substate on state
 371                           thereis (c-search-uplist-for-classkey substate))
 372             for elt = (car (last state))
 373             do (goto-char (if (consp elt) (car elt) elt))))))
 374
 375 (defun c-search-uplist-for-scopekey (state)
 376   (let ((c-class-key c-scope-key))
 377     (c-search-uplist-for-classkey state)))
 378
 379 (defun c-aggressive-search-uplist-for-scopekey ()
 380   (let ((c-class-key c-scope-key))
 381     (c-aggressive-search-uplist-for-classkey)))
 382
 383 (defun c-save-uplist (arg)
 384   ;; like up-list but return nil on error
 385   (condition-case nil
 386       (progn
 387         (up-list arg)
 388         (point))
 389     (scan-error nil)))
 390
 391 (defun c-full-parse-state ()
 392   ;; return the complete parse-state from the beginning of buffer up
 393   ;; to (point)
 394   (save-excursion
 395     (let (state s elt)
 396       (while (setq s (c-parse-state)
 397                    elt (car (last s)))
 398         (goto-char (if (consp elt) (car elt) elt))
 399         (setq state (nconc state s)))
 400       state)))
 401
 402 (defun c-get-block-scope ()
 403   ;; return a list of scoping levels for point. Every scoping level is
 404   ;; identified by thier 'class for a class scope, or 'namespace for a
 405   ;; namespace scope For 'class and 'struct scopes, optional template
 406   ;; declarations are returned.
 407   (save-excursion
 408     (let (key element keys)
 409       (while (setq key (c-aggressive-search-uplist-for-scopekey))
 410         (goto-char (aref key 0))
 411         (setq element (vector nil
 412                               (aref key 0)
 413                               (aref key 1)
 414                               nil))
 415         (cond ((looking-at c-class-scope-key)
 416                (aset element 0 'class)
 417                (c-backward-syntactic-ws)
 418                (if (eq (preceding-char) ?>)
 419                    ;; this is a templated class/struct declaration
 420                    (save-excursion
 421                      (c-backward-template-arglist)
 422                      (c-backward-token-1)
 423                      (if (looking-at c-template-key)
 424                          (aset element 3 (point))))))
 425
 426                ((looking-at c-namespace-scope-key)
 427                 (aset element 0 'namespace)))
 428
 429         (if (aref element 0)
 430             (setq keys (cons element keys))))
 431       keys)))
 432
 433 (defun c-get-scope ()
 434   ;; This is like c-get-block-scope. Additionaly, if in a function
 435   ;; declaration or definition this will add a 'defun entry at the
 436   ;; end detailing the function information (and having an optional
 437   ;; template spec). The start of the function entry is the first char
 438   ;; of the functions typespec, the last char is just after the
 439   ;; closing paren of the function defn or decl.
 440   (let ((scope (c-get-block-scope)))
 441     (save-excursion
 442       (if (c-move-to-start-of-defun (and scope (aref (car (last scope)) 1)))
 443           (let ((element (vector 'defun (point) nil nil)))
 444             (c-forward-scoped-name)
 445             (aset element 2 (point))
 446             (c-beginning-of-statement-1)
 447             (if (looking-at c-template-key)
 448                 (aset element 3 (point)))
 449             (nconc scope (list element)))
 450         scope))))
 451
 452 (defun c-scope-name (p &optional strip)
 453   ;; return the name of the scope at P. if STRIP is non-nil, strip
 454   ;; that many elements from the name
 455   (save-excursion
 456     (goto-char p)
 457     (if (looking-at c-scope-key)
 458         (c-forward-token-1))
 459     (let ((points (c-forward-scoped-name)))
 460       (c-backward-syntactic-ws)
 461       (buffer-substring-no-properties (car points)
 462                                       (or (and strip (> strip 0)
 463                                                (or (and (<= strip (length points))
 464                                                         (car
 465                                                          (last
 466                                                           (nbutlast points
 467                                                                     (1- strip)))))
 468                                                    (car points)))
 469                                           (point))))))
 470
 471 (defun c-get-class-at-point ()
 472   ;; Return block scope for class at point.
 473   (save-excursion
 474     (c-forward-syntactic-ws)
 475     (while (looking-at c-template-key)
 476       (goto-char (match-end 0))
 477       (c-forward-extended-sexp)
 478       (c-forward-syntactic-ws))
 479     (and (looking-at c-class-scope-key)
 480          (search-forward "{" nil t))
 481     (last (c-get-block-scope))))
 482
 483 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 484 ;; template functions
 485
 486 (defun c-parse-template-declaration ()
 487   ;; parse the template declaration at point. return a list of
 488   ;; cons'es of argument def ranges.
 489   (save-excursion
 490     (if (looking-at c-template-key)
 491         (c-forward-token-1)
 492       (c-forward-syntactic-ws))
 493     (if (eq (following-char) ?<)
 494         (c-parse-arglist (point)
 495                          (progn (c-forward-template-arglist) (point))))))
 496
 497 (defun c-parse-arglist (start end)
 498   ;; parse arglist between START and END. The region between START end
 499   ;; END must include the delimiteres (parens or angle brackets) even
 500   ;; though theese delimiters are completely ignored
 501   (setq end (1- end))
 502   (let (args arg-start)
 503     (save-excursion
 504       (goto-char start)
 505       (while (and (not (eobp))
 506                   (< (point) end))
 507         (forward-char 1)
 508         (c-forward-syntactic-ws)
 509         (setq arg-start (point))
 510         (condition-case nil
 511             (while (progn
 512                      (c-forward-extended-sexp)
 513                      (and (not (eobp))
 514                           (< (point) end)
 515                           (not (eq (following-char) ?,)))))
 516           (scan-error nil))
 517         (save-excursion
 518           (c-backward-syntactic-ws)
 519               (if (> (point) end)
 520                   (goto-char end))
 521               (if (> (point) arg-start)
 522                   (setq args (cons (cons arg-start (point))
 523                                    args))))))
 524     (nreverse args)))
 525
 526 (defun c-move-to-template-argument (start end)
 527   ;; move to the template argument name within the template argument
 528   ;; between START and END
 529   (if (c-move-to-initializer start end)
 530       (forward-char -1)
 531     (goto-char end))
 532   (while (and (>= (point) start)
 533               (not (c-at-symbol-p))
 534               (not (bobp)))
 535     (c-backward-extended-sexp))
 536   (c-at-symbol-p))
 537
 538 (defun c-get-template-argument-name (start end)
 539   ;; get the argument name of the template argument defined between
 540   ;; START and END
 541   (save-excursion
 542     (c-move-to-template-argument start end)
 543     (buffer-substring-no-properties (point)
 544                                     (progn
 545                                       (c-forward-token-1)
 546                                       (c-backward-syntactic-ws)
 547                                       (point)))))
 548
 549 (defun c-get-template-prefix (args)
 550   ;; return the template prefix for the template declared with
 551   ;; arguments ARGS
 552   (concat "<"
 553           (mapconcat (function (lambda (x)
 554                                  (c-get-template-argument-name (car x) (cdr x))))
 555                      args
 556                      ",")
 557           ">"))
 558
 559 (defun c-is-template-id (p)
 560   ;; return t if scoped name at P is a template_id
 561   (save-excursion
 562     (goto-char p)
 563     (if (looking-at c-scope-key)
 564         (c-forward-token-1))
 565     (c-forward-scoped-name)
 566     (c-backward-syntactic-ws)
 567     (eq (preceding-char) ?>)))
 568
 569 (defun c-move-to-initializer (start end)
 570   ;; move point to the initializer for the argument declared between
 571   ;; START and END. return t if initializer found, otherwise nil. if
 572   ;; no initializer is found, point is left at START
 573   (goto-char start)
 574   (search-forward "=" end t))
 575
 576 (defun c-get-templates (scope)
 577   ;; return list of ranges of template specs in SCOPE
 578   (loop for level in scope
 579         if (aref level 3)
 580         collect (progn
 581                   (goto-char (aref level 3))
 582                   (c-forward-token-1)
 583                   (c-forward-template-arglist)
 584                   (c-backward-syntactic-ws)
 585                   (cons (aref level 3) (point)))))
 586
 587 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 588 ;; functions to parse defuns
 589
 590 (defun c-get-full-prefix (scope &optional strip)
 591   ;; return the full prefix for scope. if STRIP is non-nil, strip the
 592   ;; name of the current method, if any.
 593   (save-excursion
 594     (loop with last-p = (last scope)
 595           for elem-p on scope
 596           for elem = (car elem-p)
 597           for next = nil then t
 598           for last = (eq elem-p last-p)
 599           if (and last strip (eq (aref elem 0) 'defun))
 600             concat (let ((name (c-scope-name (aref elem 1) 1)))
 601                      (if (> (length name) 0)
 602                          (concat (if next "::" "") name) ""))
 603           else
 604             concat (concat (if next "::" "")
 605                            (c-scope-name (aref elem 1))
 606                            (if (and (aref elem 3)
 607                                     (not (c-is-template-id (aref elem 1))))
 608                                (progn
 609                                  (goto-char (aref elem 3))
 610                                  (c-get-template-prefix
 611                                   (c-parse-template-declaration)))
 612                              "")))))
 613
 614 (defun c-parse-defun ()
 615   ;; parse function definition or declaration at point. Returns a vector
 616   ;; of positions: [template type name arglist modifiers initializers body end]
 617   (save-excursion
 618     (c-beginning-of-defun-or-decl)
 619     (let (template type name arglist modifiers initializers body end)
 620       (if (looking-at c-template-key)
 621           (progn
 622             (setq template (point))
 623             (while (looking-at c-template-key)
 624               (c-forward-token-1)
 625               (c-forward-template-arglist)
 626               (c-forward-syntactic-ws))))
 627       (setq type (point))
 628       (while (and (not (or (eq (following-char) ?\()
 629                            (c-crosses-statement-barrier-p type (point))))
 630                   (let ((point (point)))
 631                     (> (progn (c-forward-balanced-token) (c-forward-syntactic-ws) (point)) point))))
 632       (save-excursion
 633         (c-backward-scoped-name)
 634         (setq name (point))
 635         (if (eq name type)
 636             (setq type nil)))
 637       (setq arglist (point))
 638       (c-forward-sexp)
 639       (c-forward-syntactic-ws)
 640       (if (not (memq (following-char) '(?{ ?\; ?:)))
 641           (progn
 642             (setq modifiers (point))
 643             (while (not (or (memq (following-char) '(?{ ?\; ?:))
 644                             (c-crosses-statement-barrier-p modifiers (point))
 645                             (eobp)))
 646               (c-forward-extended-sexp)
 647               (c-forward-syntactic-ws))))
 648       (if (eq (following-char) ?:)
 649           (progn
 650             (setq initializers (point))
 651             (while (not (or (memq (following-char) '(?{ ?\;))
 652                             (c-crosses-statement-barrier-p initializers (point))))
 653               (c-forward-extended-sexp)
 654               (c-forward-syntactic-ws))))
 655       (if (eq (following-char) ?{)
 656           (progn
 657             (setq body (point))
 658             (c-forward-sexp)))
 659       (setq end (point))
 660       (vector template type name arglist modifiers initializers body end))))
 661
 662 (defun c-get-defun-state ()
 663   ;; this extends c-parse-defun. it returns a vector containing the
 664   ;; following items:
 665   ;;   o templates: a list of cons'es each containing the range of a
 666   ;;             template specification
 667   ;;   o type: a cons containing the range for the return type
 668   ;;             specification of the function
 669   ;;   o name: a cons containing the range for the functions name
 670   ;;   o args: a list of cons'es, each containing the range of a
 671   ;;             function argument
 672   ;;   o modifiers: a cons containing the range of the modifiers
 673   ;;   o initializers: a list of cons'es each containing the range of
 674   ;;             an initializer
 675   ;;   o body: a cons containing the range for the body or nil, if no
 676   ;;             body
 677   ;;   o prototype: nil, if body is non-nil, otherwise the end of the
 678   ;;             prototype.
 679   ;;   o scope: the scope structure (as returned by c-get-block-scope)
 680   ;;             for this function
 681   (save-excursion
 682     (let ((defun (c-parse-defun))
 683           (scope (c-get-block-scope))
 684           templates type name args modifiers initializers body prototype)
 685       (setq templates (c-get-templates scope))
 686       (if (aref defun 0)
 687           (progn
 688             (goto-char (aref defun 0))
 689             (while (looking-at c-template-key)
 690               (setq templates (nconc templates
 691                                      (list (cons (point)
 692                                                  (progn
 693                                                    (c-forward-token-1)
 694                                                    (c-forward-template-arglist)
 695                                                    (c-backward-syntactic-ws)
 696                                                    (point))))))
 697               (c-forward-syntactic-ws))))
 698       (if (aref defun 1)
 699           (progn
 700             (goto-char (aref defun 2))
 701             (c-backward-syntactic-ws)
 702             (setq type (cons (aref defun 1) (point)))))
 703       (goto-char (aref defun 3))
 704       (c-backward-syntactic-ws)
 705       (setq name (cons (aref defun 2) (point)))
 706       (goto-char (aref defun 3))
 707       (let ((start (point)))
 708         (c-forward-sexp)
 709         (setq args (c-parse-arglist start (point))))
 710       (if (aref defun 4)
 711           (progn
 712             (goto-char (or (aref defun 5) (aref defun 6) (aref defun 7)))
 713             (c-backward-syntactic-ws)
 714             (setq modifiers (cons (aref defun 4) (point)))))
 715       (if (aref defun 5)
 716           (setq initializers (c-parse-arglist (aref defun 5)
 717                                               (1+ (or (aref defun 6)
 718                                                       (aref defun 7))))))
 719       (if (aref defun 6)
 720           (setq body (cons (aref defun 6) (aref defun 7))))
 721       (if (not body)
 722           (setq prototype (1+ (aref defun 7))))
 723       (vector templates type name args modifiers
 724               initializers body prototype scope))))
 725
 726 (defun c-defun-full-name (state)
 727   ;; return the full name of the defun in state
 728   (string-replace "[ \t\n\r]+" ""
 729                   (concat (c-get-full-prefix (aref state 8))
 730                           (if (aref state 8) "::" "")
 731                           (buffer-substring-no-properties (car (aref state 2))
 732                                                           (cdr (aref state 2))))
 733                   t))
 734
 735 (defun c-defun-short-name (state)
 736   ;; return the short name of the defun in state. This is the name of the defun
 737   ;; without template args or namespace/class prefix
 738   (let (p)
 739     (save-excursion
 740       (goto-char (cdr (aref state 2)))
 741       (if (and (eq (preceding-char) ?>)
 742                (not (save-excursion
 743                       (re-search-backward (concat c-operator-word "\\=") nil t))))
 744           (c-backward-template-arglist))
 745       (c-backward-syntactic-ws)
 746       (setq p (point))
 747       (if (re-search-backward (concat c-operator-word "\\=") nil t)
 748           (goto-char (match-beginning 0))
 749         (c-backward-token-1)
 750         (if (and (c-at-symbol-p)
 751                  (eq (preceding-char) ?~))
 752             (forward-char -1)))
 753       (buffer-substring-no-properties p (point)))))
 754
 755 (defun c-goto-beginning-of-defun (defun)
 756   (goto-char (or (car (aref defun 1))
 757                  (car (aref defun 2))))
 758   (loop for point = (point)
 759         for tmpl in (reverse (aref defun 0))
 760         do (c-backward-syntactic-ws)
 761         while (= (cdr tmpl) (point))
 762         do (progn
 763              (goto-char (car tmpl))
 764              (setq point (point)))
 765         finally do (goto-char point)))
 766
 767 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 768 ;; functions to parse classes
 769
 770 (defun c-parse-class (scope)
 771   ;; parse class at point. returns vector of positions: [template
 772   ;; class bases start ( members )] each member is a cons ( type
 773   ;; . start ) where type is one of 'typedef 'class 'friend 'variable
 774   ;; 'method or 'combo (combo is a combinded struct/class/union +
 775   ;; variable declaration)
 776   (save-excursion
 777     (let ((scope (car (last scope)))
 778           end template class bases start members)
 779       (if (not (eq (aref scope 0) 'class))
 780           nil
 781         (setq template (aref scope 3))
 782         (setq class (aref scope 1))
 783         (setq start (aref scope 2))
 784         (goto-char start)
 785         (while (and (< (skip-chars-backward "^:" class) 0)
 786                     (or (progn
 787                           (forward-char -1)
 788                           (and (eq (char-before) ?:) (progn (forward-char -1) t)))
 789                         (c-in-literal))))
 790         (if (eq (following-char) ?:)
 791             (progn
 792               (forward-char 1)
 793               (c-forward-syntactic-ws)
 794               (setq bases (point))))
 795         (goto-char start)
 796         (save-excursion
 797           (c-forward-sexp)
 798           (setq end (point)))
 799         (forward-char 1)
 800         (while (progn (c-end-of-statement)
 801                       (< (point) end))
 802           (let ((bc (char-before))
 803                 (this (point)))
 804             (if (eq bc ?{)
 805                 (save-excursion
 806                   (forward-char -1)
 807                   (c-forward-sexp)
 808                   (setq this (point))))
 809             (if (or (eq bc ?\;) (eq bc ?{))
 810                 (progn
 811                   (forward-char -1)
 812                   (if (re-search-backward "=\\s-*0\\s-*\\=" start t)
 813                       (goto-char (match-beginning 0)))
 814                   (if (c-just-after-func-arglist-p)
 815                       ;; OK. It's a method (defn or decl)
 816                       (progn
 817                         (c-beginning-of-statement-1)
 818                         (setq members (cons (cons 'method (point))
 819                                             members)))
 820                     (if (eq bc ?{)
 821                         ;; this should be a class or struct decl. Maybe
 822                         ;; a variable.
 823                         (let (pos decl beg)
 824                           (setq pos (point))
 825                           (c-beginning-of-statement-1)
 826                           (setq beg (point))
 827                           (if (looking-at c-class-scope-key)
 828                               ;; it really IS a class/struct/union
 829                               (progn
 830                                 (goto-char (match-end 0))
 831                                 (c-forward-syntactic-ws)
 832                                 (setq decl (looking-at "[a-zA-Z_]"))
 833                                 (goto-char pos)
 834                                 (c-forward-sexp)
 835                                 (c-forward-syntactic-ws)
 836                                 (if (eq (following-char) ?\;)
 837                                     ;; no variable defn
 838                                     (if decl
 839                                         (setq members (cons (cons 'class beg)
 840                                                             members)))
 841                                   (save-excursion
 842                                     (goto-char this)
 843                                     (c-end-of-statement)
 844                                     (setq this (point)))
 845                                   (setq members (cons (cons (if decl 'combo 'variable)
 846                                                             beg)
 847                                                       members))))))
 848                       ;; then it's a variable decl or typedef or friend
 849                       (c-beginning-of-statement-1)
 850                       (cond ((looking-at c-typedef-key)
 851                              (setq members (cons (cons 'typedef (point)) members)))
 852                             ((looking-at c-friend-key)
 853                              (setq members (cons (cons 'friend (point)) members)))
 854                             (t
 855                              (setq members (cons (cons 'variable (point)) members))))
 856                       ))))
 857             (goto-char this)))
 858         (vector template class bases start (nreverse members))))))
 859
 860 (defun c-current-access-level ()
 861   ;; returm current access level: 'public, 'protected or 'private
 862   (save-excursion
 863     (let ((scope (car (last (c-get-block-scope)))))
 864       (while (and (re-search-backward c-access-key (aref scope 2) t)
 865                   (or (c-in-literal)
 866                       (not (eq (aref (car (c-get-block-scope)) 1) (aref scope 1))))))
 867       (loop for (re . sym) in c-access-keys
 868             if (looking-at re)
 869               return sym
 870             finally return (progn
 871                              (goto-char (aref scope 1))
 872                              (if (looking-at c-struct-scope-key)
 873                                  'public
 874                                'private))))))
 875
 876 (defun c-get-variable-members (class)
 877   ;; return list of names of all variables of CLASS
 878   (save-excursion
 879     (loop for (type . pos) in (aref class 4)
 880           for end = (progn (goto-char pos) (c-end-of-statement) (1- (point)))
 881           if (or (eq type 'variable) (eq type 'combo))
 882             collect (c-get-template-argument-name pos end))))
 883
 884 (defun c-get-variable-members-with-type (class)
 885   ;; return list of conses of (name . type) of all variables of CLASS
 886   (save-excursion
 887     (loop for (type . pos) in (aref class 4)
 888           for end = (progn (goto-char pos) (c-end-of-statement) (1- (point)))
 889           if (eq type 'variable)
 890             collect (c-get-variable-with-type pos end))))
 891
 892 (defun c-get-variable-with-type (start end)
 893   (c-move-to-template-argument start end)
 894   (let ((arg (save-excursion
 895                (buffer-substring-no-properties (point)
 896                                                (progn
 897                                                  (c-forward-token-1)
 898                                                  (c-backward-syntactic-ws)
 899                                                  (point))))))
 900     (c-backward-syntactic-ws)
 901     (cons arg (buffer-substring-no-properties start (point)))))
 902
 903 (defun c-get-base-classes (class)
 904   ;; return list of base class names (including template specs)
 905   (and (aref class 2)
 906        (save-excursion
 907          (goto-char (aref class 2))
 908          (loop while (< (point) (aref class 3))
 909                do (progn (c-forward-syntactic-ws)
 910                          (while (looking-at c-inheritance-spec-key)
 911                            (c-forward-token-1)
 912                            (c-forward-syntactic-ws)))
 913                for start = (point)
 914                do (progn (c-forward-scoped-name) (c-backward-syntactic-ws))
 915                collect (buffer-substring-no-properties start (point))
 916                do (progn
 917                     (while (and (> (skip-chars-forward "^," (aref class 3)) 0)
 918                                 (c-in-literal))
 919                       (forward-char 1))
 920                     (forward-char 1))))))
 921
 922 (provide 'cc-engine-2)
 923
 924 \f
 925 ;;; Local Variables:
 926 ;;; elisp-project-autoload-file-name: "cc-autoload.el"
 927 ;;; End: