lisp/progmodes/cc-styles.el

   1 ;;; cc-styles.el --- support for styles in CC Mode
   2
   3 ;; Copyright (C) 1985,1987,1992-2003, 2004, 2005 Free Software Foundation, Inc.
   4
   5 ;; Authors:    1998- Martin Stjernholm
   6 ;;             1992-1999 Barry A. Warsaw
   7 ;;             1987 Dave Detlefs and Stewart Clamen
   8 ;;             1985 Richard M. Stallman
   9 ;; Maintainer: bug-cc-mode@gnu.org
  10 ;; Created:    22-Apr-1997 (split from cc-mode.el)
  11 ;; Version:    See cc-mode.el
  12 ;; Keywords:   c languages oop
  13
  14 ;; This file is part of GNU Emacs.
  15
  16 ;; GNU Emacs is free software; you can redistribute it and/or modify
  17 ;; it under the terms of the GNU General Public License as published by
  18 ;; the Free Software Foundation; either version 2, or (at your option)
  19 ;; any later version.
  20
  21 ;; GNU Emacs is distributed in the hope that it will be useful,
  22 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 ;; GNU General Public License for more details.
  25
  26 ;; You should have received a copy of the GNU General Public License
  27 ;; along with GNU Emacs; see the file COPYING.  If not, write to
  28 ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  29 ;; Boston, MA 02110-1301, USA.
  30
  31 ;;; Commentary:
  32
  33 ;;; Code:
  34
  35 (eval-when-compile
  36   (let ((load-path
  37          (if (and (boundp 'byte-compile-dest-file)
  38                   (stringp byte-compile-dest-file))
  39              (cons (file-name-directory byte-compile-dest-file) load-path)
  40            load-path)))
  41     (load "cc-bytecomp" nil t)))
  42
  43 (cc-require 'cc-defs)
  44 (cc-require 'cc-vars)
  45 (cc-require 'cc-align)
  46 ;; cc-align is only indirectly required: Styles added with
  47 ;; `c-add-style' often contains references to functions defined there.
  48
  49 ;; Silence the compiler.
  50 (cc-bytecomp-defvar adaptive-fill-first-line-regexp) ; Emacs
  51 (cc-bytecomp-obsolete-fun make-local-hook) ; Marked obsolete in Emacs 21.1.
  52
  53 \f
  54 (defvar c-style-alist
  55   '(("gnu"
  56      (c-basic-offset . 2)
  57      (c-comment-only-line-offset . (0 . 0))
  58      (c-offsets-alist . ((statement-block-intro . +)
  59                          (knr-argdecl-intro . 5)
  60                          (substatement-open . +)
  61                          (substatement-label . 0)
  62                          (label . 0)
  63                          (statement-case-open . +)
  64                          (statement-cont . +)
  65                          (arglist-intro . c-lineup-arglist-intro-after-paren)
  66                          (arglist-close . c-lineup-arglist)
  67                          (inline-open . 0)
  68                          (brace-list-open . +)
  69                          ))
  70      (c-special-indent-hook . c-gnu-impose-minimum)
  71      (c-block-comment-prefix . "")
  72      )
  73     ("k&r"
  74      (c-basic-offset . 5)
  75      (c-comment-only-line-offset . 0)
  76      (c-offsets-alist . ((statement-block-intro . +)
  77                          (knr-argdecl-intro . 0)
  78                          (substatement-open . 0)
  79                          (substatement-label . 0)
  80                          (label . 0)
  81                          (statement-cont . +)
  82                          ))
  83      )
  84     ("bsd"
  85      (c-basic-offset . 8)
  86      (c-comment-only-line-offset . 0)
  87      (c-offsets-alist . ((statement-block-intro . +)
  88                          (knr-argdecl-intro . +)
  89                          (substatement-open . 0)
  90                          (substatement-label . 0)
  91                          (label . 0)
  92                          (statement-cont . +)
  93                          (inline-open . 0)
  94                          (inexpr-class . 0)
  95                          ))
  96      )
  97     ("stroustrup"
  98      (c-basic-offset . 4)
  99      (c-comment-only-line-offset . 0)
 100      (c-offsets-alist . ((statement-block-intro . +)
 101                          (substatement-open . 0)
 102                          (substatement-label . 0)
 103                          (label . 0)
 104                          (statement-cont . +)
 105                          ))
 106      )
 107     ("whitesmith"
 108      (c-basic-offset . 4)
 109      (c-comment-only-line-offset . 0)
 110      (c-offsets-alist . ((knr-argdecl-intro . +)
 111                          (label . 0)
 112                          (statement-cont . +)
 113                          (substatement-open . +)
 114                          (substatement-label . +)
 115                          (block-open . +)
 116                          (statement-block-intro . c-lineup-whitesmith-in-block)
 117                          (block-close . c-lineup-whitesmith-in-block)
 118                          (inline-open . +)
 119                          (defun-open . +)
 120                          (defun-block-intro . c-lineup-whitesmith-in-block)
 121                          (defun-close . c-lineup-whitesmith-in-block)
 122                          (brace-list-open . +)
 123                          (brace-list-intro . c-lineup-whitesmith-in-block)
 124                          (brace-entry-open . c-indent-multi-line-block)
 125                          (brace-list-close . c-lineup-whitesmith-in-block)
 126                          (class-open . +)
 127                          (inclass . c-lineup-whitesmith-in-block)
 128                          (class-close . +)
 129                          (inexpr-class . 0)
 130                          (extern-lang-open . +)
 131                          (inextern-lang . c-lineup-whitesmith-in-block)
 132                          (extern-lang-close . +)
 133                          (namespace-open . +)
 134                          (innamespace . c-lineup-whitesmith-in-block)
 135                          (namespace-close . +)
 136                          (module-open . +)
 137                          (inmodule . c-lineup-whitesmith-in-block)
 138                          (module-close . +)
 139                          (composition-open . +)
 140                          (incomposition . c-lineup-whitesmith-in-block)
 141                          (composition-close . +)
 142                          ))
 143      )
 144     ("ellemtel"
 145      (c-basic-offset . 3)
 146      (c-comment-only-line-offset . 0)
 147      (c-hanging-braces-alist     . ((substatement-open before after)))
 148      (c-offsets-alist . ((topmost-intro        . 0)
 149                          (substatement         . +)
 150                          (substatement-open    . 0)
 151                          (case-label           . +)
 152                          (access-label         . -)
 153                          (inclass              . ++)
 154                          (inline-open          . 0)
 155                          ))
 156      )
 157     ("linux"
 158      (c-basic-offset  . 8)
 159      (c-comment-only-line-offset . 0)
 160      (c-hanging-braces-alist . ((brace-list-open)
 161                                 (brace-entry-open)
 162                                 (substatement-open after)
 163                                 (block-close . c-snug-do-while)))
 164      (c-cleanup-list . (brace-else-brace))
 165      (c-offsets-alist . ((statement-block-intro . +)
 166                          (knr-argdecl-intro     . 0)
 167                          (substatement-open     . 0)
 168                          (substatement-label    . 0)
 169                          (label                 . 0)
 170                          (statement-cont        . +)
 171                          ))
 172      )
 173     ("python"
 174      (indent-tabs-mode . t)
 175      (fill-column      . 78)
 176      (c-basic-offset   . 8)
 177      (c-offsets-alist  . ((substatement-open . 0)
 178                           (inextern-lang . 0)
 179                           (arglist-intro . +)
 180                           (knr-argdecl-intro . +)
 181                           ))
 182      (c-hanging-braces-alist . ((brace-list-open)
 183                                 (brace-list-intro)
 184                                 (brace-list-close)
 185                                 (brace-entry-open)
 186                                 (substatement-open after)
 187                                 (block-close . c-snug-do-while)
 188                                 ))
 189      (c-block-comment-prefix . "")
 190      )
 191     ("java"
 192      (c-basic-offset . 4)
 193      (c-comment-only-line-offset . (0 . 0))
 194      ;; the following preserves Javadoc starter lines
 195      (c-offsets-alist . ((inline-open . 0)
 196                          (topmost-intro-cont    . +)
 197                          (statement-block-intro . +)
 198                          (knr-argdecl-intro     . 5)
 199                          (substatement-open     . +)
 200                          (substatement-label    . +)
 201                          (label                 . +)
 202                          (statement-case-open   . +)
 203                          (statement-cont        . +)
 204                          (arglist-intro  . c-lineup-arglist-intro-after-paren)
 205                          (arglist-close  . c-lineup-arglist)
 206                          (access-label   . 0)
 207                          (inher-cont     . c-lineup-java-inher)
 208                          (func-decl-cont . c-lineup-java-throws)
 209                          ))
 210      )
 211     )
 212   "Styles of indentation.
 213 Elements of this alist are of the form:
 214
 215   (STYLE-STRING [BASE-STYLE] (VARIABLE . VALUE) [(VARIABLE . VALUE) ...])
 216
 217 where STYLE-STRING is a short descriptive string used to select a
 218 style, VARIABLE is any Emacs variable, and VALUE is the intended value
 219 for that variable when using the selected style.
 220
 221 Optional BASE-STYLE if present, is a string and must follow
 222 STYLE-STRING.  BASE-STYLE names a style that this style inherits from.
 223 By default, all styles inherit from the \"user\" style, which is
 224 computed at run time.  Style loops generate errors.
 225
 226 Two variables are treated specially.  When VARIABLE is
 227 `c-offsets-alist', the VALUE is a list containing elements of the
 228 form:
 229
 230   (SYNTACTIC-SYMBOL . OFFSET)
 231
 232 as described in `c-offsets-alist'.  These are passed directly to
 233 `c-set-offset' so there is no need to set every syntactic symbol in
 234 your style, only those that are different from the default.
 235
 236 When VARIABLE is `c-special-indent-hook', its VALUE is added to
 237 `c-special-indent-hook' using `add-hook'.  If VALUE is a list, each
 238 element of the list is added with `add-hook'.
 239
 240 Do not change this variable directly.  Use the function `c-add-style'
 241 to add new styles or modify existing styles (it is not a good idea to
 242 modify existing styles -- you should create a new style that inherits
 243 the existing style.")
 244
 245 \f
 246 ;; Functions that manipulate styles
 247 (defun c-set-style-1 (conscell dont-override)
 248   ;; Set the style for one variable
 249   ;;
 250   ;; This function does not do any hidden buffer changes.
 251   (let ((attr (car conscell))
 252         (val  (cdr conscell)))
 253     (cond
 254      ;; first special variable
 255      ((eq attr 'c-offsets-alist)
 256       (let ((offsets (cond ((eq dont-override t)
 257                             c-offsets-alist)
 258                            (dont-override
 259                             (default-value 'c-offsets-alist)))))
 260         (mapcar (lambda (langentry)
 261                   (let ((langelem (car langentry))
 262                         (offset (cdr langentry)))
 263                     (unless (assq langelem offsets)
 264                       (c-set-offset langelem offset))))
 265                 val)))
 266      ;; second special variable
 267      ((eq attr 'c-special-indent-hook)
 268       ;; Maybe we should ignore dont-override here and always add new
 269       ;; hooks?
 270       (unless (cond ((eq dont-override t)
 271                      c-special-indent-hook)
 272                     (dont-override
 273                      (default-value 'c-special-indent-hook)))
 274         (if (listp val)
 275             (mapcar (lambda (func)
 276                       (add-hook 'c-special-indent-hook func t t))
 277                     val)
 278           (add-hook 'c-special-indent-hook val t t))))
 279      ;; all other variables
 280      (t (when (or (not dont-override)
 281                   (not (memq attr c-style-variables))
 282                   (eq (if (eq dont-override t)
 283                           (symbol-value attr)
 284                         (default-value attr))
 285                       'set-from-style))
 286           (set attr val)
 287           ;; Must update a number of other variables if
 288           ;; c-comment-prefix-regexp is set.
 289           (if (eq attr 'c-comment-prefix-regexp)
 290               (c-setup-paragraph-variables)))))))
 291
 292 (defun c-get-style-variables (style basestyles)
 293   ;; Return all variables in a style by resolving inheritances.
 294   ;;
 295   ;; This function does not do any hidden buffer changes.
 296   (if (not style)
 297       (copy-alist c-fallback-style)
 298     (let ((vars (cdr (or (assoc (downcase style) c-style-alist)
 299                          (assoc (upcase style) c-style-alist)
 300                          (assoc style c-style-alist)
 301                          (progn
 302                            (c-benign-error "Undefined style: %s" style)
 303                            nil)))))
 304       (let ((base (and (stringp (car-safe vars))
 305                        (prog1
 306                            (downcase (car vars))
 307                          (setq vars (cdr vars))))))
 308         (if (memq base basestyles)
 309             (c-benign-error "Style loop detected: %s in %s" base basestyles)
 310           (nconc (c-get-style-variables base (cons base basestyles))
 311                  (copy-alist vars)))))))
 312
 313 (defvar c-set-style-history nil)
 314
 315 ;;;###autoload
 316 (defun c-set-style (stylename &optional dont-override)
 317   "Set CC Mode variables to use one of several different indentation styles.
 318 STYLENAME is a string representing the desired style from the list of
 319 styles described in the variable `c-style-alist'.  See that variable
 320 for details of setting up styles.
 321
 322 The variable `c-indentation-style' always contains the buffer's current
 323 style name.
 324
 325 If the optional argument DONT-OVERRIDE is t, no style variables that
 326 already have values will be overridden.  I.e. in the case of
 327 `c-offsets-alist', syntactic symbols will only be added, and in the
 328 case of all other style variables, only those set to `set-from-style'
 329 will be reassigned.
 330
 331 If DONT-OVERRIDE is neither nil nor t, only those style variables that
 332 have default (i.e. non-buffer local) values will keep their settings
 333 while the rest will be overridden.  This is useful to avoid overriding
 334 global settings done in ~/.emacs when setting a style from a mode hook
 335 \(providing the style variables are buffer local, which is the
 336 default).
 337
 338 Obviously, setting DONT-OVERRIDE to t is useful mainly when the
 339 initial style is chosen for a CC Mode buffer by a major mode.  Since
 340 that is done internally by CC Mode, it typically won't have any effect
 341 when used elsewhere."
 342   (interactive
 343    (list (let ((completion-ignore-case t)
 344                (prompt (format "Which %s indentation style? "
 345                                mode-name)))
 346            (condition-case nil
 347                ;; The default argument is preferred over
 348                ;; initial-contents, but it only exists in Emacs >= 20
 349                ;; and XEmacs >= 21.
 350                (completing-read prompt c-style-alist nil t nil
 351                                 'c-set-style-history
 352                                 c-indentation-style)
 353              (wrong-number-of-arguments
 354               ;; If the call above failed, we fall back to the old way
 355               ;; of specifying the default value.
 356               (completing-read prompt c-style-alist nil t
 357                                (cons c-indentation-style 0)
 358                                'c-set-style-history))))))
 359   (or (stringp stylename)
 360       (error "Argument to c-set-style was not a string"))
 361   (c-initialize-builtin-style)
 362   (let ((vars (c-get-style-variables stylename nil)))
 363     (unless dont-override
 364       ;; Since we always add to c-special-indent-hook we must reset it
 365       ;; first, or else the hooks from the preceding style will
 366       ;; remain.  This is not necessary for c-offsets-alist, since
 367       ;; c-get-style-variables contains every valid offset type in the
 368       ;; fallback entry.
 369       (setq c-special-indent-hook
 370             (default-value 'c-special-indent-hook)))
 371     (mapcar (lambda (elem)
 372               (c-set-style-1 elem dont-override))
 373             ;; Need to go through the variables backwards when we
 374             ;; don't override any settings.
 375             (if (eq dont-override t) (nreverse vars) vars)))
 376   (setq c-indentation-style stylename)
 377   (c-keep-region-active))
 378
 379 ;;;###autoload
 380 (defun c-add-style (style description &optional set-p)
 381   "Adds a style to `c-style-alist', or updates an existing one.
 382 STYLE is a string identifying the style to add or update.  DESCRIPTION
 383 is an association list describing the style and must be of the form:
 384
 385   ([BASESTYLE] (VARIABLE . VALUE) [(VARIABLE . VALUE) ...])
 386
 387 See the variable `c-style-alist' for the semantics of BASESTYLE,
 388 VARIABLE and VALUE.  This function also sets the current style to
 389 STYLE using `c-set-style' if the optional SET-P flag is non-nil."
 390   (interactive
 391    (let ((stylename (completing-read "Style to add: " c-style-alist
 392                                      nil nil nil 'c-set-style-history))
 393          (descr (eval-minibuffer "Style description: ")))
 394      (list stylename descr
 395            (y-or-n-p "Set the style too? "))))
 396   (setq style (downcase style))
 397   (let ((s (assoc style c-style-alist)))
 398     (if s
 399         (setcdr s (copy-alist description)) ; replace
 400       (setq c-style-alist (cons (cons style description) c-style-alist))))
 401   (and set-p (c-set-style style)))
 402
 403 \f
 404 (defvar c-read-offset-history nil)
 405
 406 (defun c-read-offset (langelem)
 407   ;; read new offset value for LANGELEM from minibuffer. return a
 408   ;; legal value only
 409   ;;
 410   ;; This function does not do any hidden buffer changes.
 411   (let* ((oldoff  (cdr-safe (or (assq langelem c-offsets-alist)
 412                                 (assq langelem (get 'c-offsets-alist
 413                                                     'c-stylevar-fallback)))))
 414          (symname (symbol-name langelem))
 415          (defstr  (format "(default %s): " oldoff))
 416          (errmsg  (concat "Offset must be int, func, var, vector, list, "
 417                           "or [+,-,++,--,*,/] "
 418                           defstr))
 419          (prompt (concat symname " offset " defstr))
 420          (keymap (make-sparse-keymap))
 421          (minibuffer-completion-table obarray)
 422          (minibuffer-completion-predicate 'fboundp)
 423          offset input)
 424     ;; In principle completing-read is used here, but SPC is unbound
 425     ;; to make it less annoying to enter lists.
 426     (set-keymap-parent keymap minibuffer-local-completion-map)
 427     (define-key keymap " " 'self-insert-command)
 428     (while (not offset)
 429       (setq input (read-from-minibuffer prompt nil keymap t
 430                                         'c-read-offset-history
 431                                         (format "%s" oldoff)))
 432       (if (c-valid-offset input)
 433           (setq offset input)
 434         ;; error, but don't signal one, keep trying
 435         ;; to read an input value
 436         (ding)
 437         (setq prompt errmsg)))
 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                     (and c-buffer-is-cc-mode
 461                          (c-save-buffer-state
 462                              ((syntax (c-guess-basic-syntax))
 463                               (len (length syntax))
 464                               (ic (format "%s" (car (nth (1- len) syntax)))))
 465                            (cons ic 0)))
 466                     )))
 467           (offset (c-read-offset langelem)))
 468      (list langelem offset current-prefix-arg)))
 469   ;; sanity check offset
 470   (if (c-valid-offset 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)
 476                                           c-offsets-alist))
 477             (c-benign-error "%s is not a valid syntactic symbol" symbol))))
 478     (c-benign-error "Invalid indentation setting for symbol %s: %s"
 479                     symbol offset))
 480   (c-keep-region-active))
 481
 482 \f
 483 (defun c-setup-paragraph-variables ()
 484   "Fix things up for paragraph recognition and filling inside comments by
 485 incorporating the value of `c-comment-prefix-regexp' in the relevant
 486 variables."
 487   ;;
 488   ;; This function does not do any hidden buffer changes.
 489
 490   (interactive)
 491
 492   (setq c-current-comment-prefix
 493         (if (listp c-comment-prefix-regexp)
 494             (cdr-safe (or (assoc major-mode c-comment-prefix-regexp)
 495                           (assoc 'other c-comment-prefix-regexp)))
 496           c-comment-prefix-regexp))
 497
 498   (let ((comment-line-prefix
 499          (concat "[ \t]*\\(" c-current-comment-prefix "\\)[ \t]*")))
 500
 501     (setq paragraph-start (concat comment-line-prefix
 502                                   c-paragraph-start
 503                                   "\\|"
 504                                   page-delimiter)
 505           paragraph-separate (concat comment-line-prefix
 506                                      c-paragraph-separate
 507                                      "\\|"
 508                                      page-delimiter)
 509           paragraph-ignore-fill-prefix t
 510           adaptive-fill-mode t
 511           adaptive-fill-regexp
 512           (concat comment-line-prefix
 513                   (if (default-value 'adaptive-fill-regexp)
 514                       (concat "\\("
 515                               (default-value 'adaptive-fill-regexp)
 516                               "\\)")
 517                     "")))
 518
 519     (when (boundp 'adaptive-fill-first-line-regexp)
 520       ;; XEmacs (20.x) adaptive fill mode doesn't have this.
 521       (make-local-variable 'adaptive-fill-first-line-regexp)
 522       (setq adaptive-fill-first-line-regexp
 523             (concat "\\`" comment-line-prefix
 524                     ;; Maybe we should incorporate the old value here,
 525                     ;; but then we have to do all sorts of kludges to
 526                     ;; deal with the \` and \' it probably contains.
 527                     "\\'")))))
 528
 529 \f
 530 ;; Helper for setting up Filladapt mode.  It's not used by CC Mode itself.
 531
 532 (cc-bytecomp-defvar filladapt-token-table)
 533 (cc-bytecomp-defvar filladapt-token-match-table)
 534 (cc-bytecomp-defvar filladapt-token-conversion-table)
 535
 536 (defun c-setup-filladapt ()
 537   "Convenience function to configure Kyle E. Jones' Filladapt mode for
 538 CC Mode by making sure the proper entries are present on
 539 `filladapt-token-table', `filladapt-token-match-table', and
 540 `filladapt-token-conversion-table'.  This is intended to be used on
 541 `c-mode-common-hook' or similar."
 542   ;; This function is intended to be used explicitly by the end user
 543   ;; only.
 544   ;;
 545   ;; This function does not do any hidden buffer changes.
 546
 547   ;; The default configuration already handles C++ comments, but we
 548   ;; need to add handling of C block comments.  A new filladapt token
 549   ;; `c-comment' is added for that.
 550   (let (p)
 551     (setq p filladapt-token-table)
 552     (while (and p (not (eq (car-safe (cdr-safe (car-safe p))) 'c-comment)))
 553       (setq p (cdr-safe p)))
 554     (if p
 555         (setcar (car p) c-current-comment-prefix)
 556       (setq filladapt-token-table
 557             (append (list (car filladapt-token-table)
 558                           (list c-current-comment-prefix 'c-comment))
 559                     (cdr filladapt-token-table)))))
 560   (unless (assq 'c-comment filladapt-token-match-table)
 561     (setq filladapt-token-match-table
 562           (append '((c-comment c-comment))
 563                   filladapt-token-match-table)))
 564   (unless (assq 'c-comment filladapt-token-conversion-table)
 565     (setq filladapt-token-conversion-table
 566           (append '((c-comment . exact))
 567                   filladapt-token-conversion-table))))
 568
 569 \f
 570 (defun c-initialize-builtin-style ()
 571   ;; Dynamically append the default value of most variables. This is
 572   ;; crucial because future c-set-style calls will always reset the
 573   ;; variables first to the `cc-mode' style before instituting the new
 574   ;; style.  Only do this once!
 575   ;;
 576   ;; This function does not do any hidden buffer changes.
 577   (unless (get 'c-initialize-builtin-style 'is-run)
 578     (put 'c-initialize-builtin-style 'is-run t)
 579     ;;(c-initialize-cc-mode)
 580     (unless (assoc "user" c-style-alist)
 581       (let ((vars c-style-variables) var val uservars)
 582         (while vars
 583           (setq var (car vars)
 584                 val (symbol-value var)
 585                 vars (cdr vars))
 586           (cond ((eq var 'c-offsets-alist)
 587                  (or (null val)
 588                      (setq uservars (cons (cons 'c-offsets-alist val)
 589                                           uservars))))
 590                 ((not (eq val 'set-from-style))
 591                  (setq uservars (cons (cons var val)
 592                                       uservars)))))
 593         (c-add-style "user" uservars)))
 594     (unless (assoc "cc-mode" c-style-alist)
 595       (c-add-style "cc-mode" '("user")))
 596     (if c-style-variables-are-local-p
 597         (c-make-styles-buffer-local))))
 598
 599 (defun c-make-styles-buffer-local (&optional this-buf-only-p)
 600   "Make all CC Mode style variables buffer local.
 601 If `this-buf-only-p' is non-nil, the style variables will be made
 602 buffer local only in the current buffer.  Otherwise they'll be made
 603 permanently buffer local in any buffer that change their values.
 604
 605 The buffer localness of the style variables are normally controlled
 606 with the variable `c-style-variables-are-local-p', so there's seldom
 607 any reason to call this function directly."
 608   ;;
 609   ;; This function does not do any hidden buffer changes.
 610
 611   ;; style variables
 612   (let ((func (if this-buf-only-p
 613                   'make-local-variable
 614                 'make-variable-buffer-local))
 615         (varsyms (cons 'c-indentation-style (copy-alist c-style-variables))))
 616     (delq 'c-special-indent-hook varsyms)
 617     (mapcar func varsyms)
 618     ;; Hooks must be handled specially
 619     (if this-buf-only-p
 620         (make-local-hook 'c-special-indent-hook)
 621       (make-variable-buffer-local 'c-special-indent-hook)
 622       (setq c-style-variables-are-local-p t))
 623     ))
 624
 625
 626 \f
 627 (cc-provide 'cc-styles)
 628
 629 ;;; arch-tag: c764f61a-96ba-484a-a68f-101c0e9d5d2c
 630 ;;; cc-styles.el ends here