emacs-diffs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Emacs-diffs] Changes to emacs/lisp/progmodes/cc-styles.el [gnus-5_10-br


From: Miles Bader
Subject: [Emacs-diffs] Changes to emacs/lisp/progmodes/cc-styles.el [gnus-5_10-branch]
Date: Sat, 04 Sep 2004 08:19:45 -0400

Index: emacs/lisp/progmodes/cc-styles.el
diff -c /dev/null emacs/lisp/progmodes/cc-styles.el:1.31.2.1
*** /dev/null   Sat Sep  4 12:02:14 2004
--- emacs/lisp/progmodes/cc-styles.el   Sat Sep  4 12:01:11 2004
***************
*** 0 ****
--- 1,629 ----
+ ;;; cc-styles.el --- support for styles in CC Mode
+ 
+ ;; Copyright (C) 1985,1987,1992-2003 Free Software Foundation, Inc.
+ 
+ ;; Authors:    1998- Martin Stjernholm
+ ;;             1992-1999 Barry A. Warsaw
+ ;;             1987 Dave Detlefs and Stewart Clamen
+ ;;             1985 Richard M. Stallman
+ ;; Maintainer: address@hidden
+ ;; Created:    22-Apr-1997 (split from cc-mode.el)
+ ;; Version:    See cc-mode.el
+ ;; Keywords:   c languages oop
+ 
+ ;; This file is part of GNU Emacs.
+ 
+ ;; GNU Emacs is free software; you can redistribute it and/or modify
+ ;; it under the terms of the GNU General Public License as published by
+ ;; the Free Software Foundation; either version 2, or (at your option)
+ ;; any later version.
+ 
+ ;; GNU Emacs is distributed in the hope that it will be useful,
+ ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ ;; GNU General Public License for more details.
+ 
+ ;; You should have received a copy of the GNU General Public License
+ ;; along with GNU Emacs; see the file COPYING.  If not, write to
+ ;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ ;; Boston, MA 02111-1307, USA.
+ 
+ ;;; Commentary:
+ 
+ ;;; Code:
+ 
+ (eval-when-compile
+   (let ((load-path
+        (if (and (boundp 'byte-compile-dest-file)
+                 (stringp byte-compile-dest-file))
+            (cons (file-name-directory byte-compile-dest-file) load-path)
+          load-path)))
+     (load "cc-bytecomp" nil t)))
+ 
+ (cc-require 'cc-defs)
+ (cc-require 'cc-vars)
+ (cc-require 'cc-align)
+ ;; cc-align is only indirectly required: Styles added with
+ ;; `c-add-style' often contains references to functions defined there.
+ 
+ ;; Silence the compiler.
+ (cc-bytecomp-defvar adaptive-fill-first-line-regexp) ; Emacs
+ 
+ 
+ (defvar c-style-alist
+   '(("gnu"
+      (c-basic-offset . 2)
+      (c-comment-only-line-offset . (0 . 0))
+      (c-offsets-alist . ((statement-block-intro . +)
+                        (knr-argdecl-intro . 5)
+                        (substatement-open . +)
+                        (substatement-label . 0)
+                        (label . 0)
+                        (statement-case-open . +)
+                        (statement-cont . +)
+                        (arglist-intro . c-lineup-arglist-intro-after-paren)
+                        (arglist-close . c-lineup-arglist)
+                        (inline-open . 0)
+                        (brace-list-open . +)
+                        ))
+      (c-special-indent-hook . c-gnu-impose-minimum)
+      (c-block-comment-prefix . "")
+      )
+     ("k&r"
+      (c-basic-offset . 5)
+      (c-comment-only-line-offset . 0)
+      (c-offsets-alist . ((statement-block-intro . +)
+                        (knr-argdecl-intro . 0)
+                        (substatement-open . 0)
+                        (substatement-label . 0)
+                        (label . 0)
+                        (statement-cont . +)
+                        ))
+      )
+     ("bsd"
+      (c-basic-offset . 8)
+      (c-comment-only-line-offset . 0)
+      (c-offsets-alist . ((statement-block-intro . +)
+                        (knr-argdecl-intro . +)
+                        (substatement-open . 0)
+                        (substatement-label . 0)
+                        (label . 0)
+                        (statement-cont . +)
+                        (inline-open . 0)
+                        (inexpr-class . 0)
+                        ))
+      )
+     ("stroustrup"
+      (c-basic-offset . 4)
+      (c-comment-only-line-offset . 0)
+      (c-offsets-alist . ((statement-block-intro . +)
+                        (substatement-open . 0)
+                        (substatement-label . 0)
+                        (label . 0)
+                        (statement-cont . +)
+                        ))
+      )
+     ("whitesmith"
+      (c-basic-offset . 4)
+      (c-comment-only-line-offset . 0)
+      (c-offsets-alist . ((knr-argdecl-intro . +)
+                        (label . 0)
+                        (statement-cont . +)
+                        (substatement-open . +)
+                        (substatement-label . +)
+                        (block-open . +)
+                        (statement-block-intro . c-lineup-whitesmith-in-block)
+                        (block-close . c-lineup-whitesmith-in-block)
+                        (inline-open . +)
+                        (defun-open . +)
+                        (defun-block-intro . c-lineup-whitesmith-in-block)
+                        (defun-close . c-lineup-whitesmith-in-block)
+                        (brace-list-open . +)
+                        (brace-list-intro . c-lineup-whitesmith-in-block)
+                        (brace-entry-open . c-indent-multi-line-block)
+                        (brace-list-close . c-lineup-whitesmith-in-block)
+                        (class-open . +)
+                        (inclass . c-lineup-whitesmith-in-block)
+                        (class-close . +)
+                        (inexpr-class . 0)
+                        (extern-lang-open . +)
+                        (inextern-lang . c-lineup-whitesmith-in-block)
+                        (extern-lang-close . +)
+                        (namespace-open . +)
+                        (innamespace . c-lineup-whitesmith-in-block)
+                        (namespace-close . +)
+                        (module-open . +)
+                        (inmodule . c-lineup-whitesmith-in-block)
+                        (module-close . +)
+                        (composition-open . +)
+                        (incomposition . c-lineup-whitesmith-in-block)
+                        (composition-close . +)
+                        ))
+      )
+     ("ellemtel"
+      (c-basic-offset . 3)
+      (c-comment-only-line-offset . 0)
+      (c-hanging-braces-alist     . ((substatement-open before after)))
+      (c-offsets-alist . ((topmost-intro        . 0)
+                        (substatement         . +)
+                        (substatement-open    . 0)
+                          (case-label           . +)
+                          (access-label         . -)
+                          (inclass              . ++)
+                          (inline-open          . 0)
+                          ))
+      )
+     ("linux"
+      (c-basic-offset  . 8)
+      (c-comment-only-line-offset . 0)
+      (c-hanging-braces-alist . ((brace-list-open)
+                               (brace-entry-open)
+                               (substatement-open after)
+                               (block-close . c-snug-do-while)))
+      (c-cleanup-list . (brace-else-brace))
+      (c-offsets-alist . ((statement-block-intro . +)
+                        (knr-argdecl-intro     . 0)
+                        (substatement-open     . 0)
+                        (substatement-label    . 0)
+                        (label                 . 0)
+                        (statement-cont        . +)
+                        ))
+      )
+     ("python"
+      (indent-tabs-mode . t)
+      (fill-column      . 78)
+      (c-basic-offset   . 8)
+      (c-offsets-alist  . ((substatement-open . 0)
+                         (inextern-lang . 0)
+                         (arglist-intro . +)
+                         (knr-argdecl-intro . +)
+                         ))
+      (c-hanging-braces-alist . ((brace-list-open)
+                               (brace-list-intro)
+                               (brace-list-close)
+                               (brace-entry-open)
+                               (substatement-open after)
+                               (block-close . c-snug-do-while)
+                               ))
+      (c-block-comment-prefix . "")
+      )
+     ("java"
+      (c-basic-offset . 4)
+      (c-comment-only-line-offset . (0 . 0))
+      ;; the following preserves Javadoc starter lines
+      (c-offsets-alist . ((inline-open . 0)
+                        (topmost-intro-cont    . +)
+                        (statement-block-intro . +)
+                        (knr-argdecl-intro     . 5)
+                        (substatement-open     . +)
+                        (substatement-label    . +)
+                        (label                 . +)
+                        (statement-case-open   . +)
+                        (statement-cont        . +)
+                        (arglist-intro  . c-lineup-arglist-intro-after-paren)
+                        (arglist-close  . c-lineup-arglist)
+                        (access-label   . 0)
+                        (inher-cont     . c-lineup-java-inher)
+                        (func-decl-cont . c-lineup-java-throws)
+                        ))
+      )
+     )
+   "Styles of indentation.
+ Elements of this alist are of the form:
+ 
+   (STYLE-STRING [BASE-STYLE] (VARIABLE . VALUE) [(VARIABLE . VALUE) ...])
+ 
+ where STYLE-STRING is a short descriptive string used to select a
+ style, VARIABLE is any Emacs variable, and VALUE is the intended value
+ for that variable when using the selected style.
+ 
+ Optional BASE-STYLE if present, is a string and must follow
+ STYLE-STRING.  BASE-STYLE names a style that this style inherits from.
+ By default, all styles inherit from the \"user\" style, which is
+ computed at run time.  Style loops generate errors.
+ 
+ Two variables are treated specially.  When VARIABLE is
+ `c-offsets-alist', the VALUE is a list containing elements of the
+ form:
+ 
+   (SYNTACTIC-SYMBOL . OFFSET)
+ 
+ as described in `c-offsets-alist'.  These are passed directly to
+ `c-set-offset' so there is no need to set every syntactic symbol in
+ your style, only those that are different from the default.
+ 
+ When VARIABLE is `c-special-indent-hook', its VALUE is added to
+ `c-special-indent-hook' using `add-hook'.  If VALUE is a list, each
+ element of the list is added with `add-hook'.
+ 
+ Do not change this variable directly.  Use the function `c-add-style'
+ to add new styles or modify existing styles (it is not a good idea to
+ modify existing styles -- you should create a new style that inherits
+ the existing style.")
+ 
+ 
+ ;; Functions that manipulate styles
+ (defun c-set-style-1 (conscell dont-override)
+   ;; Set the style for one variable
+   ;;
+   ;; This function does not do any hidden buffer changes.
+   (let ((attr (car conscell))
+       (val  (cdr conscell)))
+     (cond
+      ;; first special variable
+      ((eq attr 'c-offsets-alist)
+       (let ((offsets (cond ((eq dont-override t)
+                           c-offsets-alist)
+                          (dont-override
+                           (default-value 'c-offsets-alist)))))
+       (mapcar (lambda (langentry)
+                 (let ((langelem (car langentry))
+                       (offset (cdr langentry)))
+                   (unless (assq langelem offsets)
+                     (c-set-offset langelem offset))))
+               val)))
+      ;; second special variable
+      ((eq attr 'c-special-indent-hook)
+       ;; Maybe we should ignore dont-override here and always add new
+       ;; hooks?
+       (unless (cond ((eq dont-override t)
+                    c-special-indent-hook)
+                   (dont-override
+                    (default-value 'c-special-indent-hook)))
+       (if (listp val)
+           (mapcar (lambda (func)
+                     (add-hook 'c-special-indent-hook func t t))
+                   val)
+         (add-hook 'c-special-indent-hook val t t))))
+      ;; all other variables
+      (t (when (or (not dont-override)
+                 (not (memq attr c-style-variables))
+                 (eq (if (eq dont-override t)
+                         (symbol-value attr)
+                       (default-value attr))
+                     'set-from-style))
+         (set attr val)
+         ;; Must update a number of other variables if
+         ;; c-comment-prefix-regexp is set.
+         (if (eq attr 'c-comment-prefix-regexp)
+             (c-setup-paragraph-variables)))))))
+ 
+ (defun c-get-style-variables (style basestyles)
+   ;; Return all variables in a style by resolving inheritances.
+   ;;
+   ;; This function does not do any hidden buffer changes.
+   (if (not style)
+       (copy-alist c-fallback-style)
+     (let ((vars (cdr (or (assoc (downcase style) c-style-alist)
+                        (assoc (upcase style) c-style-alist)
+                        (assoc style c-style-alist)
+                        (progn
+                          (c-benign-error "Undefined style: %s" style)
+                          nil)))))
+       (let ((base (and (stringp (car-safe vars))
+                      (prog1
+                          (downcase (car vars))
+                        (setq vars (cdr vars))))))
+       (if (memq base basestyles)
+           (c-benign-error "Style loop detected: %s in %s" base basestyles)
+         (nconc (c-get-style-variables base (cons base basestyles))
+                (copy-alist vars)))))))
+ 
+ (defvar c-set-style-history nil)
+ 
+ ;;;###autoload
+ (defun c-set-style (stylename &optional dont-override)
+   "Set CC Mode variables to use one of several different indentation styles.
+ STYLENAME is a string representing the desired style from the list of
+ styles described in the variable `c-style-alist'.  See that variable
+ for details of setting up styles.
+ 
+ The variable `c-indentation-style' always contains the buffer's current
+ style name.
+ 
+ If the optional argument DONT-OVERRIDE is t, no style variables that
+ already have values will be overridden.  I.e. in the case of
+ `c-offsets-alist', syntactic symbols will only be added, and in the
+ case of all other style variables, only those set to `set-from-style'
+ will be reassigned.
+ 
+ If DONT-OVERRIDE is neither nil nor t, only those style variables that
+ have default (i.e. non-buffer local) values will keep their settings
+ while the rest will be overridden.  This is useful to avoid overriding
+ global settings done in ~/.emacs when setting a style from a mode hook
+ \(providing the style variables are buffer local, which is the
+ default).
+ 
+ Obviously, setting DONT-OVERRIDE to t is useful mainly when the
+ initial style is chosen for a CC Mode buffer by a major mode.  Since
+ that is done internally by CC Mode, it typically won't have any effect
+ when used elsewhere."
+   (interactive
+    (list (let ((completion-ignore-case t)
+              (prompt (format "Which %s indentation style? "
+                              mode-name)))
+          (condition-case nil
+              ;; The default argument is preferred over
+              ;; initial-contents, but it only exists in Emacs >= 20
+              ;; and XEmacs >= 21.
+              (completing-read prompt c-style-alist nil t nil
+                               'c-set-style-history
+                               c-indentation-style)
+            (wrong-number-of-arguments
+             ;; If the call above failed, we fall back to the old way
+             ;; of specifying the default value.
+             (completing-read prompt c-style-alist nil t
+                              (cons c-indentation-style 0)
+                              'c-set-style-history))))))
+   (or (stringp stylename)
+       (error "Argument to c-set-style was not a string"))
+   (c-initialize-builtin-style)
+   (let ((vars (c-get-style-variables stylename nil)))
+     (unless dont-override
+       ;; Since we always add to c-special-indent-hook we must reset it
+       ;; first, or else the hooks from the preceding style will
+       ;; remain.  This is not necessary for c-offsets-alist, since
+       ;; c-get-style-variables contains every valid offset type in the
+       ;; fallback entry.
+       (setq c-special-indent-hook
+           (default-value 'c-special-indent-hook)))
+     (mapcar (lambda (elem)
+             (c-set-style-1 elem dont-override))
+           ;; Need to go through the variables backwards when we
+           ;; don't override any settings.
+           (if (eq dont-override t) (nreverse vars) vars)))
+   (setq c-indentation-style stylename)
+   (c-keep-region-active))
+ 
+ ;;;###autoload
+ (defun c-add-style (style description &optional set-p)
+   "Adds a style to `c-style-alist', or updates an existing one.
+ STYLE is a string identifying the style to add or update.  DESCRIPTION
+ is an association list describing the style and must be of the form:
+ 
+   ([BASESTYLE] (VARIABLE . VALUE) [(VARIABLE . VALUE) ...])
+ 
+ See the variable `c-style-alist' for the semantics of BASESTYLE,
+ VARIABLE and VALUE.  This function also sets the current style to
+ STYLE using `c-set-style' if the optional SET-P flag is non-nil."
+   (interactive
+    (let ((stylename (completing-read "Style to add: " c-style-alist
+                                    nil nil nil 'c-set-style-history))
+          (descr (eval-minibuffer "Style description: ")))
+      (list stylename descr
+          (y-or-n-p "Set the style too? "))))
+   (setq style (downcase style))
+   (let ((s (assoc style c-style-alist)))
+     (if s
+         (setcdr s (copy-alist description)) ; replace
+       (setq c-style-alist (cons (cons style description) c-style-alist))))
+   (and set-p (c-set-style style)))
+ 
+ 
+ (defvar c-read-offset-history nil)
+ 
+ (defun c-read-offset (langelem)
+   ;; read new offset value for LANGELEM from minibuffer. return a
+   ;; legal value only
+   ;;
+   ;; This function does not do any hidden buffer changes.
+   (let* ((oldoff  (cdr-safe (or (assq langelem c-offsets-alist)
+                               (assq langelem (get 'c-offsets-alist
+                                                   'c-stylevar-fallback)))))
+        (symname (symbol-name langelem))
+        (defstr  (format "(default %s): " oldoff))
+        (errmsg  (concat "Offset must be int, func, var, vector, list, "
+                         "or [+,-,++,--,*,/] "
+                         defstr))
+        (prompt (concat symname " offset " defstr))
+        (keymap (make-sparse-keymap))
+        (minibuffer-completion-table obarray)
+        (minibuffer-completion-predicate 'fboundp)
+        offset input)
+     ;; In principle completing-read is used here, but SPC is unbound
+     ;; to make it less annoying to enter lists.
+     (set-keymap-parent keymap minibuffer-local-completion-map)
+     (define-key keymap " " 'self-insert-command)
+     (while (not offset)
+       (setq input (read-from-minibuffer prompt nil keymap t
+                                       'c-read-offset-history
+                                       (format "%s" oldoff)))
+       (if (c-valid-offset input)
+         (setq offset input)
+       ;; error, but don't signal one, keep trying
+       ;; to read an input value
+       (ding)
+       (setq prompt errmsg)))
+     offset))
+ 
+ ;;;###autoload
+ (defun c-set-offset (symbol offset &optional ignored)
+   "Change the value of a syntactic element symbol in `c-offsets-alist'.
+ SYMBOL is the syntactic element symbol to change and OFFSET is the new
+ offset for that syntactic element.  The optional argument is not used
+ and exists only for compatibility reasons."
+   (interactive
+    (let* ((langelem
+          (intern (completing-read
+                   (concat "Syntactic symbol to change"
+                           (if current-prefix-arg " or add" "")
+                           ": ")
+                   (mapcar
+                    #'(lambda (langelem)
+                        (cons (format "%s" (car langelem)) nil))
+                    (get 'c-offsets-alist 'c-stylevar-fallback))
+                   nil (not current-prefix-arg)
+                   ;; initial contents tries to be the last element
+                   ;; on the syntactic analysis list for the current
+                   ;; line
+                   (and c-buffer-is-cc-mode
+                        (c-save-buffer-state
+                            ((syntax (c-guess-basic-syntax))
+                             (len (length syntax))
+                             (ic (format "%s" (car (nth (1- len) syntax)))))
+                          (cons ic 0)))
+                   )))
+         (offset (c-read-offset langelem)))
+      (list langelem offset current-prefix-arg)))
+   ;; sanity check offset
+   (if (c-valid-offset offset)
+       (let ((entry (assq symbol c-offsets-alist)))
+       (if entry
+           (setcdr entry offset)
+         (if (assq symbol (get 'c-offsets-alist 'c-stylevar-fallback))
+             (setq c-offsets-alist (cons (cons symbol offset)
+                                         c-offsets-alist))
+           (c-benign-error "%s is not a valid syntactic symbol" symbol))))
+     (c-benign-error "Invalid indentation setting for symbol %s: %s"
+                   symbol offset))
+   (c-keep-region-active))
+ 
+ 
+ (defun c-setup-paragraph-variables ()
+   "Fix things up for paragraph recognition and filling inside comments by
+ incorporating the value of `c-comment-prefix-regexp' in the relevant
+ variables."
+   ;;
+   ;; This function does not do any hidden buffer changes.
+ 
+   (interactive)
+ 
+   (setq c-current-comment-prefix
+       (if (listp c-comment-prefix-regexp)
+           (cdr-safe (or (assoc major-mode c-comment-prefix-regexp)
+                         (assoc 'other c-comment-prefix-regexp)))
+         c-comment-prefix-regexp))
+ 
+   (let ((comment-line-prefix
+        (concat "[ \t]*\\(" c-current-comment-prefix "\\)[ \t]*")))
+ 
+     (setq paragraph-start (concat comment-line-prefix
+                                 c-paragraph-start
+                                 "\\|"
+                                 page-delimiter)
+         paragraph-separate (concat comment-line-prefix
+                                    c-paragraph-separate
+                                    "\\|"
+                                    page-delimiter)
+         paragraph-ignore-fill-prefix t
+         adaptive-fill-mode t
+         adaptive-fill-regexp
+         (concat comment-line-prefix
+                 (if (default-value 'adaptive-fill-regexp)
+                     (concat "\\("
+                             (default-value 'adaptive-fill-regexp)
+                             "\\)")
+                   "")))
+ 
+     (when (boundp 'adaptive-fill-first-line-regexp)
+       ;; XEmacs (20.x) adaptive fill mode doesn't have this.
+       (make-local-variable 'adaptive-fill-first-line-regexp)
+       (setq adaptive-fill-first-line-regexp
+           (concat "\\`" comment-line-prefix
+                   ;; Maybe we should incorporate the old value here,
+                   ;; but then we have to do all sorts of kludges to
+                   ;; deal with the \` and \' it probably contains.
+                   "\\'")))))
+ 
+ 
+ ;; Helper for setting up Filladapt mode.  It's not used by CC Mode itself.
+ 
+ (cc-bytecomp-defvar filladapt-token-table)
+ (cc-bytecomp-defvar filladapt-token-match-table)
+ (cc-bytecomp-defvar filladapt-token-conversion-table)
+ 
+ (defun c-setup-filladapt ()
+   "Convenience function to configure Kyle E. Jones' Filladapt mode for
+ CC Mode by making sure the proper entries are present on
+ `filladapt-token-table', `filladapt-token-match-table', and
+ `filladapt-token-conversion-table'.  This is intended to be used on
+ `c-mode-common-hook' or similar."
+   ;; This function is intended to be used explicitly by the end user
+   ;; only.
+   ;;
+   ;; This function does not do any hidden buffer changes.
+ 
+   ;; The default configuration already handles C++ comments, but we
+   ;; need to add handling of C block comments.  A new filladapt token
+   ;; `c-comment' is added for that.
+   (let (p)
+     (setq p filladapt-token-table)
+     (while (and p (not (eq (car-safe (cdr-safe (car-safe p))) 'c-comment)))
+       (setq p (cdr-safe p)))
+     (if p
+       (setcar (car p) c-current-comment-prefix)
+       (setq filladapt-token-table
+           (append (list (car filladapt-token-table)
+                         (list c-current-comment-prefix 'c-comment))
+                   (cdr filladapt-token-table)))))
+   (unless (assq 'c-comment filladapt-token-match-table)
+     (setq filladapt-token-match-table
+         (append '((c-comment c-comment))
+                 filladapt-token-match-table)))
+   (unless (assq 'c-comment filladapt-token-conversion-table)
+     (setq filladapt-token-conversion-table
+         (append '((c-comment . exact))
+                 filladapt-token-conversion-table))))
+ 
+ 
+ (defun c-initialize-builtin-style ()
+   ;; Dynamically append the default value of most variables. This is
+   ;; crucial because future c-set-style calls will always reset the
+   ;; variables first to the `cc-mode' style before instituting the new
+   ;; style.  Only do this once!
+   ;;
+   ;; This function does not do any hidden buffer changes.
+   (unless (get 'c-initialize-builtin-style 'is-run)
+     (put 'c-initialize-builtin-style 'is-run t)
+     ;;(c-initialize-cc-mode)
+     (unless (assoc "user" c-style-alist)
+       (let ((vars c-style-variables) var val uservars)
+       (while vars
+         (setq var (car vars)
+               val (symbol-value var)
+               vars (cdr vars))
+         (cond ((eq var 'c-offsets-alist)
+                (or (null val)
+                    (setq uservars (cons (cons 'c-offsets-alist val)
+                                         uservars))))
+               ((not (eq val 'set-from-style))
+                (setq uservars (cons (cons var val)
+                                     uservars)))))
+       (c-add-style "user" uservars)))
+     (unless (assoc "cc-mode" c-style-alist)
+       (c-add-style "cc-mode" '("user")))
+     (if c-style-variables-are-local-p
+       (c-make-styles-buffer-local))))
+ 
+ (defun c-make-styles-buffer-local (&optional this-buf-only-p)
+   "Make all CC Mode style variables buffer local.
+ If `this-buf-only-p' is non-nil, the style variables will be made
+ buffer local only in the current buffer.  Otherwise they'll be made
+ permanently buffer local in any buffer that change their values.
+ 
+ The buffer localness of the style variables are normally controlled
+ with the variable `c-style-variables-are-local-p', so there's seldom
+ any reason to call this function directly."
+   ;;
+   ;; This function does not do any hidden buffer changes.
+ 
+   ;; style variables
+   (let ((func (if this-buf-only-p
+                 'make-local-variable
+               'make-variable-buffer-local))
+       (varsyms (cons 'c-indentation-style (copy-alist c-style-variables))))
+     (delq 'c-special-indent-hook varsyms)
+     (mapcar func varsyms)
+     ;; Hooks must be handled specially
+     (if this-buf-only-p
+       (make-local-hook 'c-special-indent-hook)
+       (make-variable-buffer-local 'c-special-indent-hook)
+       (setq c-style-variables-are-local-p t))
+     ))
+ 
+ 
+ 
+ (cc-provide 'cc-styles)
+ 
+ ;;; arch-tag: c764f61a-96ba-484a-a68f-101c0e9d5d2c
+ ;;; cc-styles.el ends here




reply via email to

[Prev in Thread] Current Thread [Next in Thread]