lisp/progmodes/cc-styles.el

   1 ;;; cc-styles.el --- support for styles in CC Mode
   2
   3 ;; Copyright (C) 1985,1987,1992-2000 Free Software Foundation, Inc.
   4
   5 ;; Authors:    2000- Martin Stjernholm
   6 ;;             1998-1999 Barry A. Warsaw and Martin Stjernholm
   7 ;;             1992-1997 Barry A. Warsaw
   8 ;;             1987 Dave Detlefs and Stewart Clamen
   9 ;;             1985 Richard M. Stallman
  10 ;; Maintainer: bug-cc-mode@gnu.org
  11 ;; Created:    22-Apr-1997 (split from cc-mode.el)
  12 ;; Version:    See cc-mode.el
  13 ;; Keywords:   c languages oop
  14
  15 ;; This file is part of GNU Emacs.
  16
  17 ;; GNU Emacs is free software; you can redistribute it and/or modify
  18 ;; it under the terms of the GNU General Public License as published by
  19 ;; the Free Software Foundation; either version 2, or (at your option)
  20 ;; any later version.
  21
  22 ;; GNU Emacs is distributed in the hope that it will be useful,
  23 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  24 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25 ;; GNU General Public License for more details.
  26
  27 ;; You should have received a copy of the GNU General Public License
  28 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  29 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  30 ;; Boston, MA 02111-1307, USA.
  31
  32 (eval-when-compile
  33   (let ((load-path
  34          (if (and (boundp 'byte-compile-current-file)
  35                   (stringp byte-compile-current-file))
  36              (cons (file-name-directory byte-compile-current-file)
  37                    load-path)
  38            load-path)))
  39     (load "cc-defs" nil t)))
  40 (require 'cc-vars)
  41
  42
  43 \f
  44 ;; Warning: don't eval-defun this constant or you'll break style inheritance.
  45 (defconst c-style-alist
  46   '(("gnu"
  47      (c-basic-offset . 2)
  48      (c-comment-only-line-offset . (0 . 0))
  49      (c-offsets-alist . ((statement-block-intro . +)
  50                          (knr-argdecl-intro . 5)
  51                          (substatement-open . +)
  52                          (label . 0)
  53                          (statement-case-open . +)
  54                          (statement-cont . +)
  55                          (arglist-intro . c-lineup-arglist-intro-after-paren)
  56                          (arglist-close . c-lineup-arglist)
  57                          (inline-open . 0)
  58                          (brace-list-open . +)
  59                          ))
  60      (c-special-indent-hook . c-gnu-impose-minimum)
  61      (c-block-comment-prefix . "")
  62      )
  63     ("k&r"
  64      (c-basic-offset . 5)
  65      (c-comment-only-line-offset . 0)
  66      (c-offsets-alist . ((statement-block-intro . +)
  67                          (knr-argdecl-intro . 0)
  68                          (substatement-open . 0)
  69                          (label . 0)
  70                          (statement-cont . +)
  71                          ))
  72      )
  73     ("bsd"
  74      (c-basic-offset . 8)
  75      (c-comment-only-line-offset . 0)
  76      (c-offsets-alist . ((statement-block-intro . +)
  77                          (knr-argdecl-intro . +)
  78                          (substatement-open . 0)
  79                          (label . 0)
  80                          (statement-cont . +)
  81                          (inline-open . 0)
  82                          (inexpr-class . 0)
  83                          ))
  84      )
  85     ("stroustrup"
  86      (c-basic-offset . 4)
  87      (c-comment-only-line-offset . 0)
  88      (c-offsets-alist . ((statement-block-intro . +)
  89                          (substatement-open . 0)
  90                          (label . 0)
  91                          (statement-cont . +)
  92                          ))
  93      )
  94     ("whitesmith"
  95      (c-basic-offset . 4)
  96      (c-comment-only-line-offset . 0)
  97      (c-offsets-alist . ((knr-argdecl-intro . +)
  98                          (label . 0)
  99                          (statement-cont . +)
 100                          (substatement-open . +)
 101                          (block-open . +)
 102                          (statement-block-intro . c-lineup-whitesmith-in-block)
 103                          (block-close . c-lineup-whitesmith-in-block)
 104                          (inline-open . +)
 105                          (defun-open . +)
 106                          (defun-block-intro . c-lineup-whitesmith-in-block)
 107                          (defun-close . c-lineup-whitesmith-in-block)
 108                          (brace-list-open . +)
 109                          (brace-list-intro . c-lineup-whitesmith-in-block)
 110                          (brace-entry-open . c-indent-multi-line-block)
 111                          (brace-list-close . c-lineup-whitesmith-in-block)
 112                          (class-open . +)
 113                          (inclass . c-lineup-whitesmith-in-block)
 114                          (class-close . +)
 115                          (inexpr-class . 0)
 116                          (extern-lang-open . +)
 117                          (inextern-lang . c-lineup-whitesmith-in-block)
 118                          (extern-lang-close . +)
 119                          (namespace-open . +)
 120                          (innamespace . c-lineup-whitesmith-in-block)
 121                          (namespace-close . +)
 122                          ))
 123      )
 124     ("ellemtel"
 125      (c-basic-offset . 3)
 126      (c-comment-only-line-offset . 0)
 127      (c-hanging-braces-alist     . ((substatement-open before after)))
 128      (c-offsets-alist . ((topmost-intro        . 0)
 129                          (topmost-intro-cont   . 0)
 130                          (substatement         . +)
 131                          (substatement-open    . 0)
 132                          (case-label           . +)
 133                          (access-label         . -)
 134                          (inclass              . ++)
 135                          (inline-open          . 0)
 136                          ))
 137      )
 138     ("linux"
 139      (c-basic-offset  . 8)
 140      (c-comment-only-line-offset . 0)
 141      (c-hanging-braces-alist . ((brace-list-open)
 142                                 (brace-entry-open)
 143                                 (substatement-open after)
 144                                 (block-close . c-snug-do-while)))
 145      (c-cleanup-list . (brace-else-brace))
 146      (c-offsets-alist . ((statement-block-intro . +)
 147                          (knr-argdecl-intro     . 0)
 148                          (substatement-open     . 0)
 149                          (label                 . 0)
 150                          (statement-cont        . +)
 151                          ))
 152      )
 153     ("python"
 154      (indent-tabs-mode . t)
 155      (fill-column      . 78)
 156      (c-basic-offset   . 8)
 157      (c-offsets-alist  . ((substatement-open . 0)
 158                           (inextern-lang . 0)
 159                           (arglist-intro . +)
 160                           (knr-argdecl-intro . +)
 161                           ))
 162      (c-hanging-braces-alist . ((brace-list-open)
 163                                 (brace-list-intro)
 164                                 (brace-list-close)
 165                                 (brace-entry-open)
 166                                 (substatement-open after)
 167                                 (block-close . c-snug-do-while)
 168                                 ))
 169      (c-block-comment-prefix . "")
 170      )
 171     ("java"
 172      (c-basic-offset . 4)
 173      (c-comment-only-line-offset . (0 . 0))
 174      ;; the following preserves Javadoc starter lines
 175      (c-offsets-alist . ((inline-open . 0)
 176                          (topmost-intro-cont    . +)
 177                          (statement-block-intro . +)
 178                          (knr-argdecl-intro     . 5)
 179                          (substatement-open     . +)
 180                          (label                 . +)
 181                          (statement-case-open   . +)
 182                          (statement-cont        . +)
 183                          (arglist-intro  . c-lineup-arglist-intro-after-paren)
 184                          (arglist-close  . c-lineup-arglist)
 185                          (access-label   . 0)
 186                          (inher-cont     . c-lineup-java-inher)
 187                          (func-decl-cont . c-lineup-java-throws)
 188                          ))
 189      )
 190     )
 191   "Styles of indentation.
 192 Elements of this alist are of the form:
 193
 194   (STYLE-STRING [BASE-STYLE] (VARIABLE . VALUE) [(VARIABLE . VALUE) ...])
 195
 196 where STYLE-STRING is a short descriptive string used to select a
 197 style, VARIABLE is any Emacs variable, and VALUE is the intended value
 198 for that variable when using the selected style.
 199
 200 Optional BASE-STYLE if present, is a string and must follow
 201 STYLE-STRING.  BASE-STYLE names a style that this style inherits from.
 202 By default, all styles inherit from the \"user\" style, which is
 203 computed at run time.  Style loops generate errors.
 204
 205 Two variables are treated specially.  When VARIABLE is
 206 `c-offsets-alist', the VALUE is a list containing elements of the
 207 form:
 208
 209   (SYNTACTIC-SYMBOL . OFFSET)
 210
 211 as described in `c-offsets-alist'.  These are passed directly to
 212 `c-set-offset' so there is no need to set every syntactic symbol in
 213 your style, only those that are different from the default.
 214
 215 When VARIABLE is `c-special-indent-hook', its VALUE is added to
 216 `c-special-indent-hook' using `add-hook'.  If VALUE is a list, each
 217 element of the list is added with `add-hook'.
 218
 219 Do not change this variable directly.  Use the function `c-add-style'
 220 to add new styles or modify existing styles (it is not a good idea to
 221 modify existing styles -- you should create a new style that inherits
 222 the existing style.")
 223
 224
 225 \f
 226 ;; Functions that manipulate styles
 227 (defun c-set-style-1 (conscell dont-override)
 228   ;; Set the style for one variable
 229   (let ((attr (car conscell))
 230         (val  (cdr conscell)))
 231     (cond
 232      ;; first special variable
 233      ((eq attr 'c-offsets-alist)
 234       (mapcar
 235        (function
 236         (lambda (langentry)
 237           (let ((langelem (car langentry))
 238                 (offset (cdr langentry)))
 239             (unless (and dont-override
 240                          (assq langelem c-offsets-alist))
 241               (c-set-offset langelem offset))
 242             )))
 243        (if dont-override (reverse val) val)))
 244      ;; second special variable
 245      ((eq attr 'c-special-indent-hook)
 246       (let ((add-func (if dont-override
 247                           (lambda (func)
 248                             (unless (memq func c-special-indent-hook)
 249                               (add-hook 'c-special-indent-hook func t)))
 250                         (lambda (func)
 251                           (add-hook 'c-special-indent-hook func)))))
 252         (if (listp val)
 253             (mapcar add-func (if dont-override (reverse val) val))
 254           (funcall add-func val))))
 255      ;; all other variables
 256      (t (if (or (not dont-override)
 257                 (not (memq attr c-style-variables))
 258                 (eq (symbol-value attr) 'set-from-style))
 259             (set attr val))))
 260     ))
 261
 262 (defun c-get-style-variables (style basestyles)
 263   ;; Return all variables in a style by resolving inheritances.
 264   (let ((vars (cdr (or (assoc (downcase style) c-style-alist)
 265                        (assoc (upcase style) c-style-alist)
 266                        (assoc style c-style-alist)
 267                        (error "Undefined style: %s" style)))))
 268     (if (string-equal style "user")
 269         (copy-alist vars)
 270       (let ((base (if (stringp (car vars))
 271                       (prog1
 272                           (downcase (car vars))
 273                         (setq vars (cdr vars)))
 274                     "user")))
 275         (if (memq base basestyles)
 276             (error "Style loop detected: %s in %s" base basestyles))
 277         (nconc (c-get-style-variables base (cons base basestyles))
 278                (copy-alist vars))))))
 279
 280 (defvar c-set-style-history nil)
 281
 282 ;;;###autoload
 283 (defun c-set-style (stylename &optional dont-override)
 284   "Set CC Mode variables to use one of several different indentation styles.
 285 STYLENAME is a string representing the desired style from the list of
 286 styles described in the variable `c-style-alist'.  See that variable
 287 for details of setting up styles.
 288
 289 The variable `c-indentation-style' always contains the buffer's current
 290 style name.
 291
 292 If the optional argument DONT-OVERRIDE is non-nil, no style variables
 293 that already have values will be overridden.  I.e. in the case of
 294 `c-offsets-alist', syntactic symbols will only be added, and in the
 295 case of all other style variables, only those set to `set-from-style'
 296 will be reassigned.
 297
 298 Obviously, specifying DONT-OVERRIDE is useful mainly when the initial
 299 style is chosen for a CC Mode buffer by a major mode.  Since this is
 300 done internally by CC Mode, there's hardly ever a reason to use it."
 301   (interactive (list (let ((completion-ignore-case t)
 302                            (prompt (format "Which %s indentation style? "
 303                                            mode-name)))
 304                        (completing-read prompt c-style-alist nil t
 305                                         (cons c-indentation-style 0)
 306                                         'c-set-style-history))))
 307   (c-initialize-builtin-style)
 308   (let ((vars (c-get-style-variables stylename nil)))
 309     (mapcar (lambda (elem)
 310               (c-set-style-1 elem dont-override))
 311             ;; Need to go through the variables backwards when we
 312             ;; don't override.
 313             (if dont-override (nreverse vars) vars)))
 314   (setq c-indentation-style stylename)
 315   (c-keep-region-active))
 316
 317 ;;;###autoload
 318 (defun c-add-style (style descrip &optional set-p)
 319   "Adds a style to `c-style-alist', or updates an existing one.
 320 STYLE is a string identifying the style to add or update.  DESCRIP is
 321 an association list describing the style and must be of the form:
 322
 323   ([BASESTYLE] (VARIABLE . VALUE) [(VARIABLE . VALUE) ...])
 324
 325 See the variable `c-style-alist' for the semantics of BASESTYLE,
 326 VARIABLE and VALUE.  This function also sets the current style to
 327 STYLE using `c-set-style' if the optional SET-P flag is non-nil."
 328   (interactive
 329    (let ((stylename (completing-read "Style to add: " c-style-alist
 330                                      nil nil nil 'c-set-style-history))
 331          (description (eval-minibuffer "Style description: ")))
 332      (list stylename description
 333            (y-or-n-p "Set the style too? "))))
 334   (setq style (downcase style))
 335   (let ((s (assoc style c-style-alist)))
 336     (if s
 337         (setcdr s (copy-alist descrip)) ; replace
 338       (setq c-style-alist (cons (cons style descrip) c-style-alist))))
 339   (and set-p (c-set-style style)))
 340
 341
 342 \f
 343 (defun c-evaluate-offset (offset langelem symbol)
 344   ;; offset can be a number, a function, a variable, a list, or one of
 345   ;; the symbols + or -
 346   (cond
 347    ((eq offset '+)         (setq offset c-basic-offset))
 348    ((eq offset '-)         (setq offset (- c-basic-offset)))
 349    ((eq offset '++)        (setq offset (* 2 c-basic-offset)))
 350    ((eq offset '--)        (setq offset (* 2 (- c-basic-offset))))
 351    ((eq offset '*)         (setq offset (/ c-basic-offset 2)))
 352    ((eq offset '/)         (setq offset (/ (- c-basic-offset) 2)))
 353    ((functionp offset)     (setq offset (funcall offset langelem)))
 354    ((listp offset)
 355     (setq offset
 356           (let (done)
 357             (while (and (not done) offset)
 358               (setq done (c-evaluate-offset (car offset) langelem symbol)
 359                     offset (cdr offset)))
 360             (if (not done)
 361                 (if c-strict-syntax-p
 362                     (error "No offset found for syntactic symbol %s" symbol)
 363                   0)
 364               done))))
 365    ((not (numberp offset)) (setq offset (symbol-value offset)))
 366    )
 367   offset)
 368
 369 (defun c-get-offset (langelem)
 370   ;; Get offset from LANGELEM which is a cons cell of the form:
 371   ;; (SYMBOL . RELPOS).  The symbol is matched against
 372   ;; c-offsets-alist and the offset found there is either returned,
 373   ;; or added to the indentation at RELPOS.  If RELPOS is nil, then
 374   ;; the offset is simply returned.
 375   (let* ((symbol (car langelem))
 376          (relpos (cdr langelem))
 377          (match  (assq symbol c-offsets-alist))
 378          (offset (cdr-safe match)))
 379     (if (not match)
 380         (if c-strict-syntax-p
 381             (error "No offset found for syntactic symbol %s" symbol)
 382           (setq offset 0
 383                 relpos 0))
 384       (setq offset (c-evaluate-offset offset langelem symbol)))
 385     (+ (if (and relpos
 386                 (< relpos (c-point 'bol)))
 387            (save-excursion
 388              (goto-char relpos)
 389              (current-column))
 390          0)
 391        (or (and (numberp offset) offset)
 392            (and (symbolp offset) (symbol-value offset))
 393            0))
 394     ))
 395
 396
 397 \f
 398 (defvar c-read-offset-history nil)
 399
 400 (defun c-read-offset (langelem)
 401   ;; read new offset value for LANGELEM from minibuffer. return a
 402   ;; legal value only
 403   (let* ((oldoff  (cdr-safe (or (assq langelem c-offsets-alist)
 404                                 (assq langelem (get 'c-offsets-alist
 405                                                     'c-stylevar-fallback)))))
 406          (symname (symbol-name langelem))
 407          (defstr  (format "(default %s): " oldoff))
 408          (errmsg  (concat "Offset must be int, func, var, list, "
 409                           "or [+,-,++,--,*,/] "
 410                           defstr))
 411          (prompt (concat symname " offset " defstr))
 412          offset input interned raw)
 413     (while (not offset)
 414       (setq input (completing-read prompt obarray 'fboundp nil nil
 415                                    'c-read-offset-history)
 416             offset (cond ((string-equal "" input) oldoff)  ; default
 417                          ((string-equal "+" input) '+)
 418                          ((string-equal "-" input) '-)
 419                          ((string-equal "++" input) '++)
 420                          ((string-equal "--" input) '--)
 421                          ((string-equal "*" input) '*)
 422                          ((string-equal "/" input) '/)
 423                          ((string-match "^-?[0-9]+$" input)
 424                           (string-to-int input))
 425                          ;; a symbol with a function binding
 426                          ((fboundp (setq interned (intern input)))
 427                           interned)
 428                          ;; a lambda function
 429                          ((c-safe (functionp (setq raw (read input))))
 430                           raw)
 431                          ;; a symbol with variable binding
 432                          ((boundp interned) interned)
 433                          ;; error, but don't signal one, keep trying
 434                          ;; to read an input value
 435                          (t (ding)
 436                             (setq prompt errmsg)
 437                             nil))))
 438     offset))
 439
 440 ;;;###autoload
 441 (defun c-set-offset (symbol offset &optional ignored)
 442   "Change the value of a syntactic element symbol in `c-offsets-alist'.
 443 SYMBOL is the syntactic element symbol to change and OFFSET is the new
 444 offset for that syntactic element.  The optional argument is not used
 445 and exists only for compatibility reasons."
 446   (interactive
 447    (let* ((langelem
 448            (intern (completing-read
 449                     (concat "Syntactic symbol to change"
 450                             (if current-prefix-arg " or add" "")
 451                             ": ")
 452                     (mapcar
 453                      #'(lambda (langelem)
 454                          (cons (format "%s" (car langelem)) nil))
 455                      (get 'c-offsets-alist 'c-stylevar-fallback))
 456                     nil (not current-prefix-arg)
 457                     ;; initial contents tries to be the last element
 458                     ;; on the syntactic analysis list for the current
 459                     ;; line
 460                     (let* ((syntax (c-guess-basic-syntax))
 461                            (len (length syntax))
 462                            (ic (format "%s" (car (nth (1- len) syntax)))))
 463                       (cons ic 0))
 464                     )))
 465           (offset (c-read-offset langelem)))
 466      (list langelem offset current-prefix-arg)))
 467   ;; sanity check offset
 468   (unless (c-valid-offset offset)
 469     (error "Offset must be int, func, var, list, or in [+,-,++,--,*,/]: %s"
 470            offset))
 471   (let ((entry (assq symbol c-offsets-alist)))
 472     (if entry
 473         (setcdr entry offset)
 474       (if (assq symbol (get 'c-offsets-alist 'c-stylevar-fallback))
 475           (setq c-offsets-alist (cons (cons symbol offset) c-offsets-alist))
 476         (error "%s is not a valid syntactic symbol" symbol))))
 477   (c-keep-region-active))
 478
 479
 480 \f
 481 (defun c-initialize-builtin-style ()
 482   ;; Dynamically append the default value of most variables. This is
 483   ;; crucial because future c-set-style calls will always reset the
 484   ;; variables first to the `cc-mode' style before instituting the new
 485   ;; style.  Only do this once!
 486   (unless (get 'c-initialize-builtin-style 'is-run)
 487     (put 'c-initialize-builtin-style 'is-run t)
 488     (c-initialize-cc-mode)
 489     (or (assoc "cc-mode" c-style-alist)
 490         (assoc "user" c-style-alist)
 491         (progn
 492           (c-add-style
 493            "user"
 494            (mapcar
 495             (lambda (var)
 496               (let ((val (symbol-value var)))
 497                 (cons var
 498                       (cond ((eq var 'c-offsets-alist)
 499                              (mapcar
 500                               (lambda (langentry)
 501                                 (setq langentry (or (assq (car langentry) val)
 502                                                     langentry))
 503                                 (cons (car langentry)
 504                                       (cdr langentry)))
 505                               (get var 'c-stylevar-fallback)))
 506                             ((eq var 'c-special-indent-hook)
 507                              val)
 508                             (t
 509                              (if (eq val 'set-from-style)
 510                                  (get var 'c-stylevar-fallback)
 511                                val))))))
 512             c-style-variables))
 513           (c-add-style "cc-mode" '("user"))))
 514     (if c-style-variables-are-local-p
 515         (c-make-styles-buffer-local))))
 516
 517 (defun c-make-styles-buffer-local (&optional this-buf-only-p)
 518   "Make all CC Mode style variables buffer local.
 519 If you edit primarily one style of C (or C++, Objective-C, Java, etc)
 520 code, you probably want style variables to be global.  This is the
 521 default.
 522
 523 If you edit many different styles of C (or C++, Objective-C, Java,
 524 etc) at the same time, you probably want the CC Mode style variables
 525 to be buffer local.  If you do, it's advicable to set any CC Mode
 526 style variables in a hook function (e.g. off of `c-mode-common-hook'),
 527 instead of at the top level of your ~/.emacs file.
 528
 529 This function makes all the CC Mode style variables buffer local.
 530 Call it after CC Mode is loaded into your Emacs environment.
 531 Conversely, set the variable `c-style-variables-are-local-p' to t in
 532 your .emacs file, before CC Mode is loaded, and this function will be
 533 automatically called when CC Mode is loaded.
 534
 535 Optional argument, when non-nil, means use `make-local-variable'
 536 instead of `make-variable-buffer-local'."
 537   ;; style variables
 538   (let ((func (if this-buf-only-p
 539                   'make-local-variable
 540                 'make-variable-buffer-local))
 541         (varsyms (cons 'c-indentation-style (copy-alist c-style-variables))))
 542     (delq 'c-special-indent-hook varsyms)
 543     (mapcar func varsyms)
 544     ;; Hooks must be handled specially
 545     (if this-buf-only-p
 546         (make-local-hook 'c-special-indent-hook)
 547       (make-variable-buffer-local 'c-special-indent-hook)
 548       (setq c-style-variables-are-local-p t))
 549     ))
 550
 551
 552 \f
 553 (provide 'cc-styles)
 554 ;;; cc-styles.el ends here