[Top][All Lists]
[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
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Emacs-diffs] Changes to emacs/lisp/progmodes/cc-styles.el [gnus-5_10-branch],
Miles Bader <=