--- /dev/null
+;;; cc-align.el --- custom indentation functions for CC Mode
+
+;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
+
+;; Authors: 1992-1997 Barry A. Warsaw
+;; 1987 Dave Detlefs and Stewart Clamen
+;; 1985 Richard M. Stallman
+;; Maintainer: cc-mode-help@python.org
+;; Created: 22-Apr-1997 (split from cc-mode.el)
+;; Version: 5.12
+;; 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.
+
+(eval-when-compile
+ (require 'cc-defs)
+ (require 'cc-vars)
+ (require 'cc-engine)
+ (require 'cc-langs))
+
+\f
+;; Standard indentation line-ups
+(defun c-lineup-arglist (langelem)
+ ;; lineup the current arglist line with the arglist appearing just
+ ;; after the containing paren which starts the arglist.
+ (save-excursion
+ (let* ((containing-sexp
+ (save-excursion
+ ;; arglist-cont-nonempty gives relpos ==
+ ;; to boi of containing-sexp paren. This
+ ;; is good when offset is +, but bad
+ ;; when it is c-lineup-arglist, so we
+ ;; have to special case a kludge here.
+ (if (memq (car langelem) '(arglist-intro arglist-cont-nonempty))
+ (progn
+ (beginning-of-line)
+ (backward-up-list 1)
+ (skip-chars-forward " \t" (c-point 'eol)))
+ (goto-char (cdr langelem)))
+ (point)))
+ (langelem-col (c-langelem-col langelem t)))
+ (if (save-excursion
+ (beginning-of-line)
+ (looking-at "[ \t]*)"))
+ (progn (goto-char (match-end 0))
+ (forward-sexp -1)
+ (forward-char 1)
+ (c-forward-syntactic-ws)
+ (- (current-column) langelem-col))
+ (goto-char containing-sexp)
+ (or (eolp)
+ (not (memq (char-after) '(?{ ?\( )))
+ (let ((eol (c-point 'eol))
+ (here (progn
+ (forward-char 1)
+ (skip-chars-forward " \t")
+ (point))))
+ (c-forward-syntactic-ws)
+ (if (< (point) eol)
+ (goto-char here))))
+ (- (current-column) langelem-col)
+ ))))
+
+(defun c-lineup-arglist-intro-after-paren (langelem)
+ ;; lineup an arglist-intro line to just after the open paren
+ (save-excursion
+ (let ((langelem-col (c-langelem-col langelem t))
+ (ce-curcol (save-excursion
+ (beginning-of-line)
+ (backward-up-list 1)
+ (skip-chars-forward " \t" (c-point 'eol))
+ (current-column))))
+ (- ce-curcol langelem-col -1))))
+
+(defun c-lineup-arglist-close-under-paren (langelem)
+ ;; lineup an arglist-intro line to just after the open paren
+ (save-excursion
+ (let ((langelem-col (c-langelem-col langelem t))
+ (ce-curcol (save-excursion
+ (beginning-of-line)
+ (backward-up-list 1)
+ (current-column))))
+ (- ce-curcol langelem-col))))
+
+(defun c-lineup-streamop (langelem)
+ ;; lineup stream operators
+ (save-excursion
+ (let ((langelem-col (c-langelem-col langelem)))
+ (re-search-forward "<<\\|>>" (c-point 'eol) 'move)
+ (goto-char (match-beginning 0))
+ (- (current-column) langelem-col))))
+
+(defun c-lineup-multi-inher (langelem)
+ ;; line up multiple inheritance lines
+ (save-excursion
+ (let ((eol (c-point 'eol))
+ (here (point))
+ (langelem-col (c-langelem-col langelem)))
+ (skip-chars-forward "^:" eol)
+ (skip-chars-forward " \t:" eol)
+ (if (or (eolp)
+ (looking-at c-comment-start-regexp))
+ (c-forward-syntactic-ws here))
+ (- (current-column) langelem-col)
+ )))
+
+(defun c-lineup-java-inher (langelem)
+ ;; line up Java implements and extends continuations
+ (save-excursion
+ (let ((langelem-col (c-langelem-col langelem)))
+ (forward-word 1)
+ (if (looking-at "[ \t]*$")
+ langelem-col
+ (c-forward-syntactic-ws)
+ (- (current-column) langelem-col)))))
+
+(defun c-lineup-java-throws (langelem)
+ ;; lineup func-decl-cont's in Java which are continuations of throws
+ ;; declarations. If `throws' starts the previous line, line up to
+ ;; just after that keyword. If not, lineup under the previous line.
+ (save-excursion
+ (let ((iopl (c-point 'iopl))
+ (langelem-col (c-langelem-col langelem t))
+ (extra 0))
+ (back-to-indentation)
+ (cond
+ ((looking-at "throws[ \t\n]")
+ (goto-char (cdr langelem))
+ (setq extra c-basic-offset))
+ ((and (goto-char iopl)
+ (looking-at "throws[ \t\n]"))
+ (forward-word 1)
+ (skip-chars-forward " \t")
+ (when (eolp)
+ (back-to-indentation)
+ (setq extra c-basic-offset)))
+ (t (goto-char iopl)))
+ (+ (- (current-column) langelem-col) extra))))
+
+(defun c-lineup-C-comments (langelem)
+ ;; line up C block comment continuation lines
+ (save-excursion
+ (let ((here (point))
+ (stars (progn (back-to-indentation)
+ (skip-chars-forward "*")))
+ (langelem-col (c-langelem-col langelem)))
+ (back-to-indentation)
+ (if (not (re-search-forward "/\\([*]+\\)" (c-point 'eol) t))
+ (progn
+ (if (not (looking-at "[*]+"))
+ (progn
+ ;; we now have to figure out where this comment begins.
+ (goto-char here)
+ (back-to-indentation)
+ (if (looking-at "[*]+/")
+ (progn (goto-char (match-end 0))
+ (forward-comment -1))
+ (goto-char (cdr langelem))
+ (back-to-indentation))))
+ (- (current-column) langelem-col))
+ (if (zerop stars)
+ (progn
+ (skip-chars-forward " \t")
+ (- (current-column) langelem-col))
+ ;; how many stars on comment opening line? if greater than
+ ;; on current line, align left. if less than or equal,
+ ;; align right. this should also pick up Javadoc style
+ ;; comments.
+ (if (> (length (match-string 1)) stars)
+ (progn
+ (back-to-indentation)
+ (- (current-column) -1 langelem-col))
+ (- (current-column) stars langelem-col))
+ )))))
+
+(defun c-lineup-comment (langelem)
+ ;; support old behavior for comment indentation. we look at
+ ;; c-comment-only-line-offset to decide how to indent comment
+ ;; only-lines
+ (save-excursion
+ (back-to-indentation)
+ ;; this highly kludgiforous flag prevents the mapcar over
+ ;; c-syntactic-context from entering an infinite loop
+ (let ((recurse-prevention-flag (boundp 'recurse-prevention-flag)))
+ (cond
+ ;; CASE 1: preserve comment-column
+ (recurse-prevention-flag 0)
+ ((= (current-column) comment-column)
+ ;; we have to subtract out all other indentation
+ (- comment-column (apply '+ (mapcar 'c-get-offset
+ c-syntactic-context))))
+ ;; indent as specified by c-comment-only-line-offset
+ ((not (bolp))
+ (or (car-safe c-comment-only-line-offset)
+ c-comment-only-line-offset))
+ (t
+ (or (cdr-safe c-comment-only-line-offset)
+ (car-safe c-comment-only-line-offset)
+ -1000)) ;jam it against the left side
+ ))))
+
+(defun c-lineup-runin-statements (langelem)
+ ;; line up statements in coding standards which place the first
+ ;; statement on the same line as the block opening brace.
+ (if (eq (char-after (cdr langelem)) ?{)
+ (save-excursion
+ (let ((langelem-col (c-langelem-col langelem)))
+ (forward-char 1)
+ (skip-chars-forward " \t")
+ (- (current-column) langelem-col)))
+ 0))
+
+(defun c-lineup-math (langelem)
+ ;; line up math statement-cont after the equals
+ (save-excursion
+ (let ((equalp (save-excursion
+ (goto-char (c-point 'boi))
+ (skip-chars-forward "^=" (c-point 'eol))
+ (and (eq (char-after) ?=)
+ (- (point) (c-point 'boi)))))
+ (langelem-col (c-langelem-col langelem))
+ donep)
+ (while (and (not donep)
+ (< (point) (c-point 'eol)))
+ (skip-chars-forward "^=" (c-point 'eol))
+ (if (c-in-literal (cdr langelem))
+ (forward-char 1)
+ (setq donep t)))
+ (if (not (eq (char-after) ?=))
+ ;; there's no equal sign on the line
+ c-basic-offset
+ ;; calculate indentation column after equals and ws, unless
+ ;; our line contains an equals sign
+ (if (not equalp)
+ (progn
+ (forward-char 1)
+ (skip-chars-forward " \t")
+ (setq equalp 0)))
+ (- (current-column) equalp langelem-col))
+ )))
+
+(defun c-lineup-ObjC-method-call (langelem)
+ ;; Line up methods args as elisp-mode does with function args: go to
+ ;; the position right after the message receiver, and if you are at
+ ;; (eolp) indent the current line by a constant offset from the
+ ;; opening bracket; otherwise we are looking at the first character
+ ;; of the first method call argument, so lineup the current line
+ ;; with it.
+ (save-excursion
+ (let* ((extra (save-excursion
+ (back-to-indentation)
+ (c-backward-syntactic-ws (cdr langelem))
+ (if (eq (char-before) ?:)
+ (- c-basic-offset)
+ 0)))
+ (open-bracket-pos (cdr langelem))
+ (open-bracket-col (progn
+ (goto-char open-bracket-pos)
+ (current-column)))
+ (target-col (progn
+ (forward-char)
+ (forward-sexp)
+ (skip-chars-forward " \t")
+ (if (eolp)
+ (+ open-bracket-col c-basic-offset)
+ (current-column))))
+ )
+ (- target-col open-bracket-col extra))))
+
+(defun c-lineup-ObjC-method-args (langelem)
+ ;; Line up the colons that separate args. This is done trying to
+ ;; align colons vertically.
+ (save-excursion
+ (let* ((here (c-point 'boi))
+ (curcol (progn (goto-char here) (current-column)))
+ (eol (c-point 'eol))
+ (relpos (cdr langelem))
+ (first-col-column (progn
+ (goto-char relpos)
+ (skip-chars-forward "^:" eol)
+ (and (eq (char-after) ?:)
+ (current-column)))))
+ (if (not first-col-column)
+ c-basic-offset
+ (goto-char here)
+ (skip-chars-forward "^:" eol)
+ (if (eq (char-after) ?:)
+ (+ curcol (- first-col-column (current-column)))
+ c-basic-offset)))))
+
+(defun c-lineup-ObjC-method-args-2 (langelem)
+ ;; Line up the colons that separate args. This is done trying to
+ ;; align the colon on the current line with the previous one.
+ (save-excursion
+ (let* ((here (c-point 'boi))
+ (curcol (progn (goto-char here) (current-column)))
+ (eol (c-point 'eol))
+ (relpos (cdr langelem))
+ (prev-col-column (progn
+ (skip-chars-backward "^:" relpos)
+ (and (eq (char-before) ?:)
+ (- (current-column) 1)))))
+ (if (not prev-col-column)
+ c-basic-offset
+ (goto-char here)
+ (skip-chars-forward "^:" eol)
+ (if (eq (char-after) ?:)
+ (+ curcol (- prev-col-column (current-column)))
+ c-basic-offset)))))
+
+(defun c-snug-do-while (syntax pos)
+ "Dynamically calculate brace hanginess for do-while statements.
+Using this function, `while' clauses that end a `do-while' block will
+remain on the same line as the brace that closes that block.
+
+See `c-hanging-braces-alist' for how to utilize this function as an
+ACTION associated with `block-close' syntax."
+ (save-excursion
+ (let (langelem)
+ (if (and (eq syntax 'block-close)
+ (setq langelem (assq 'block-close c-syntactic-context))
+ (progn (goto-char (cdr langelem))
+ (if (eq (char-after) ?{)
+ (c-safe (forward-sexp -1)))
+ (looking-at "\\<do\\>[^_]")))
+ '(before)
+ '(before after)))))
+
+(defun c-gnu-impose-minimum ()
+ "Imposes a minimum indentation for lines inside a top-level construct.
+The variable `c-label-minimum-indentation' specifies the minimum
+indentation amount."
+ (let ((non-top-levels '(defun-block-intro statement statement-cont
+ statement-block-intro statement-case-intro
+ statement-case-open substatement substatement-open
+ case-label label do-while-closure else-clause
+ ))
+ (syntax c-syntactic-context)
+ langelem)
+ (while syntax
+ (setq langelem (car (car syntax))
+ syntax (cdr syntax))
+ ;; don't adjust comment-only lines
+ (cond ((eq langelem 'comment-intro)
+ (setq syntax nil))
+ ((memq langelem non-top-levels)
+ (save-excursion
+ (setq syntax nil)
+ (back-to-indentation)
+ (if (zerop (current-column))
+ (insert (make-string c-label-minimum-indentation 32)))
+ ))
+ ))))
+
+\f
+;; Useful for c-hanging-semi&comma-criteria
+(defun c-semi&comma-inside-parenlist ()
+ "Determine if a newline should be added after a semicolon.
+If a comma was inserted, no determination is made. If a semicolon was
+inserted inside a parenthesis list, no newline is added otherwise a
+newline is added. In either case, checking is stopped. This supports
+exactly the old newline insertion behavior."
+ ;; newline only after semicolon, but only if that semicolon is not
+ ;; inside a parenthesis list (e.g. a for loop statement)
+ (if (not (eq last-command-char ?\;))
+ nil ; continue checking
+ (if (condition-case nil
+ (save-excursion
+ (up-list -1)
+ (not (eq (char-after) ?\()))
+ (error t))
+ t
+ 'stop)))
+
+\f
+(provide 'cc-align)
+;;; cc-align.el ends here
--- /dev/null
+;;; cc-cmds.el --- user level commands for CC Mode
+
+;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
+
+;; Authors: 1992-1997 Barry A. Warsaw
+;; 1987 Dave Detlefs and Stewart Clamen
+;; 1985 Richard M. Stallman
+;; Maintainer: cc-mode-help@python.org
+;; Created: 22-Apr-1997 (split from cc-mode.el)
+;; Version: 5.12
+;; 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.
+
+\f
+(defun c-calculate-state (arg prevstate)
+ ;; Calculate the new state of PREVSTATE, t or nil, based on arg. If
+ ;; arg is nil or zero, toggle the state. If arg is negative, turn
+ ;; the state off, and if arg is positive, turn the state on
+ (if (or (not arg)
+ (zerop (setq arg (prefix-numeric-value arg))))
+ (not prevstate)
+ (> arg 0)))
+
+;; Auto-newline and hungry-delete
+(defun c-toggle-auto-state (arg)
+ "Toggle auto-newline feature.
+Optional numeric ARG, if supplied turns on auto-newline when positive,
+turns it off when negative, and just toggles it when zero.
+
+When the auto-newline feature is enabled (as evidenced by the `/a' or
+`/ah' on the modeline after the mode name) newlines are automatically
+inserted after special characters such as brace, comma, semi-colon,
+and colon."
+ (interactive "P")
+ (setq c-auto-newline (c-calculate-state arg c-auto-newline))
+ (c-update-modeline)
+ (c-keep-region-active))
+
+(defun c-toggle-hungry-state (arg)
+ "Toggle hungry-delete-key feature.
+Optional numeric ARG, if supplied turns on hungry-delete when positive,
+turns it off when negative, and just toggles it when zero.
+
+When the hungry-delete-key feature is enabled (as evidenced by the
+`/h' or `/ah' on the modeline after the mode name) the delete key
+gobbles all preceding whitespace in one fell swoop."
+ (interactive "P")
+ (setq c-hungry-delete-key (c-calculate-state arg c-hungry-delete-key))
+ (c-update-modeline)
+ (c-keep-region-active))
+
+(defun c-toggle-auto-hungry-state (arg)
+ "Toggle auto-newline and hungry-delete-key features.
+Optional numeric ARG, if supplied turns on auto-newline and
+hungry-delete when positive, turns them off when negative, and just
+toggles them when zero.
+
+See `c-toggle-auto-state' and `c-toggle-hungry-state' for details."
+ (interactive "P")
+ (setq c-auto-newline (c-calculate-state arg c-auto-newline))
+ (setq c-hungry-delete-key (c-calculate-state arg c-hungry-delete-key))
+ (c-update-modeline)
+ (c-keep-region-active))
+
+\f
+;; Electric keys
+
+;; Note: In XEmacs 20.3 the Delete and BackSpace keysyms have been
+;; separated and "\177" is no longer an alias for both keys. Also,
+;; the variable delete-key-deletes-forward controls in which direction
+;; the Delete keysym deletes characters. The functions
+;; c-electric-delete and c-electric-backspace attempt to deal with
+;; this new functionality. For Emacs 19 and XEmacs 19 backwards
+;; compatibility, the old behavior has moved to c-electric-backspace
+;; and c-backspace-function.
+
+(defun c-electric-backspace (arg)
+ "Deletes preceding character or whitespace.
+If `c-hungry-delete-key' is non-nil, as evidenced by the \"/h\" or
+\"/ah\" string on the mode line, then all preceding whitespace is
+consumed. If however an ARG is supplied, or `c-hungry-delete-key' is
+nil, or point is inside a literal then the function in the variable
+`c-backspace-function' is called.
+
+See also \\[c-electric-delete]."
+ (interactive "P")
+ (if (or (not c-hungry-delete-key)
+ arg
+ (c-in-literal))
+ (funcall c-backspace-function (prefix-numeric-value arg))
+ (let ((here (point)))
+ (skip-chars-backward " \t\n")
+ (if (/= (point) here)
+ (delete-region (point) here)
+ (funcall c-backspace-function 1)
+ ))))
+
+(defun c-electric-delete (arg)
+ "Deletes preceding or following character or whitespace.
+
+The behavior of this function depends on the variable
+`delete-key-deletes-forward'. If this variable is nil (or does not
+exist, as in older Emacsen), then this function behaves identical to
+\\[c-electric-backspace].
+
+If `delete-key-deletes-forward' is non-nil, then deletion occurs in
+the forward direction. So if `c-hungry-delete-key' is non-nil, as
+evidenced by the \"/h\" or \"/ah\" string on the mode line, then all
+following whitespace is consumed. If however an ARG is supplied, or
+`c-hungry-delete-key' is nil, or point is inside a literal then the
+function in the variable `c-delete-function' is called."
+ (interactive "P")
+ (if (and (boundp 'delete-key-deletes-forward)
+ delete-key-deletes-forward)
+ (if (or (not c-hungry-delete-key)
+ arg
+ (c-in-literal))
+ (funcall c-delete-function (prefix-numeric-value arg))
+ (let ((here (point)))
+ (skip-chars-forward " \t\n")
+ (if (/= (point) here)
+ (delete-region (point) here)
+ (funcall c-delete-function 1))))
+ ;; act just like c-electric-backspace
+ (c-electric-backspace arg)))
+
+(defun c-electric-pound (arg)
+ "Electric pound (`#') insertion.
+Inserts a `#' character specially depending on the variable
+`c-electric-pound-behavior'. If a numeric ARG is supplied, or if
+point is inside a literal, nothing special happens."
+ (interactive "P")
+ (if (or (c-in-literal)
+ arg
+ (not (memq 'alignleft c-electric-pound-behavior)))
+ ;; do nothing special
+ (self-insert-command (prefix-numeric-value arg))
+ ;; place the pound character at the left edge
+ (let ((pos (- (point-max) (point)))
+ (bolp (bolp)))
+ (beginning-of-line)
+ (delete-horizontal-space)
+ (insert-char last-command-char 1)
+ (and (not bolp)
+ (goto-char (- (point-max) pos)))
+ )))
+
+(defun c-electric-brace (arg)
+ "Insert a brace.
+
+If the auto-newline feature is turned on, as evidenced by the \"/a\"
+or \"/ah\" string on the mode line, newlines are inserted before and
+after braces based on the value of `c-hanging-braces-alist'.
+
+Also, the line is re-indented unless a numeric ARG is supplied, there
+are non-whitespace characters present on the line after the brace, or
+the brace is inserted inside a literal."
+ (interactive "P")
+ (let* ((c-state-cache (c-parse-state))
+ (safepos (c-safe-position (point) c-state-cache))
+ (literal (c-in-literal safepos)))
+ ;; if we're in a literal, or we're not at the end of the line, or
+ ;; a numeric arg is provided, or auto-newlining is turned off,
+ ;; then just insert the character.
+ (if (or literal arg
+; (not c-auto-newline)
+ (not (looking-at "[ \t]*$")))
+ (self-insert-command (prefix-numeric-value arg))
+ (let* ((syms '(class-open class-close defun-open defun-close
+ inline-open inline-close brace-list-open brace-list-close
+ brace-list-intro brace-list-entry block-open block-close
+ substatement-open statement-case-open
+ extern-lang-open extern-lang-close))
+ ;; we want to inhibit blinking the paren since this will
+ ;; be most disruptive. we'll blink it ourselves later on
+ (old-blink-paren blink-paren-function)
+ blink-paren-function
+ (insertion-point (point))
+ delete-temp-newline
+ (preserve-p (eq 32 (char-syntax (char-before))))
+ ;; shut this up too
+ (c-echo-syntactic-information-p nil)
+ (syntax (progn
+ ;; only insert a newline if there is
+ ;; non-whitespace behind us
+ (if (save-excursion
+ (skip-chars-backward " \t")
+ (not (bolp)))
+ (progn (newline)
+ (setq delete-temp-newline t)))
+ (self-insert-command (prefix-numeric-value arg))
+ ;; state cache doesn't change
+ (c-guess-basic-syntax)))
+ (newlines (and
+ c-auto-newline
+ (or (c-lookup-lists syms syntax c-hanging-braces-alist)
+ '(ignore before after)))))
+ ;; If syntax is a function symbol, then call it using the
+ ;; defined semantics.
+ (if (and (not (consp (cdr newlines)))
+ (functionp (cdr newlines)))
+ (let ((c-syntactic-context syntax))
+ (setq newlines
+ (funcall (cdr newlines) (car newlines) insertion-point))))
+ ;; does a newline go before the open brace?
+ (if (memq 'before newlines)
+ ;; we leave the newline we've put in there before,
+ ;; but we need to re-indent the line above
+ (let ((pos (- (point-max) (point)))
+ (here (point))
+ (c-state-cache c-state-cache))
+ (forward-line -1)
+ ;; we may need to update the cache. this should still be
+ ;; faster than recalculating the state in many cases
+ (save-excursion
+ (save-restriction
+ (narrow-to-region here (point))
+ (if (and (c-safe (progn (backward-up-list -1) t))
+ (memq (char-before) '(?\) ?}))
+ (progn (widen)
+ (c-safe (progn (forward-sexp -1) t))))
+ (setq c-state-cache
+ (c-hack-state (point) 'open c-state-cache))
+ (if (and (car c-state-cache)
+ (not (consp (car c-state-cache)))
+ (<= (point) (car c-state-cache)))
+ (setq c-state-cache (cdr c-state-cache))
+ ))))
+ (let ((here (point))
+ (shift (c-indent-line)))
+ (setq c-state-cache (c-adjust-state (c-point 'bol) here
+ (- shift) c-state-cache)))
+ (goto-char (- (point-max) pos))
+ ;; if the buffer has changed due to the indentation, we
+ ;; need to recalculate syntax for the current line, but
+ ;; we won't need to update the state cache.
+ (if (/= (point) here)
+ (setq syntax (c-guess-basic-syntax))))
+ ;; must remove the newline we just stuck in (if we really did it)
+ (and delete-temp-newline
+ (save-excursion
+ ;; if there is whitespace before point, then preserve
+ ;; at least one space.
+ (delete-indentation)
+ (just-one-space)
+ (if (not preserve-p)
+ (delete-char -1))))
+ ;; since we're hanging the brace, we need to recalculate
+ ;; syntax. Update the state to accurately reflect the
+ ;; beginning of the line. We punt if we cross any open or
+ ;; closed parens because its just too hard to modify the
+ ;; known state. This limitation will be fixed in v5.
+ (save-excursion
+ (let ((bol (c-point 'bol)))
+ (if (zerop (car (parse-partial-sexp bol (1- (point)))))
+ (setq c-state-cache (c-whack-state bol c-state-cache)
+ syntax (c-guess-basic-syntax))
+ ;; gotta punt. this requires some horrible kludgery
+ (beginning-of-line)
+ (makunbound 'c-state-cache)
+ (setq c-state-cache (c-parse-state)
+ syntax nil))))
+ )
+ ;; now adjust the line's indentation. don't update the state
+ ;; cache since c-guess-basic-syntax isn't called when the
+ ;; syntax is passed to c-indent-line
+ (let ((here (point))
+ (shift (c-indent-line syntax)))
+ (setq c-state-cache (c-adjust-state (c-point 'bol) here
+ (- shift) c-state-cache)))
+ ;; Do all appropriate clean ups
+ (let ((here (point))
+ (pos (- (point-max) (point)))
+ mbeg mend)
+ ;; clean up empty defun braces
+ (if (and c-auto-newline
+ (memq 'empty-defun-braces c-cleanup-list)
+ (eq last-command-char ?\})
+ (c-intersect-lists '(defun-close class-close inline-close)
+ syntax)
+ (progn
+ (forward-char -1)
+ (skip-chars-backward " \t\n")
+ (eq (char-before) ?\{))
+ ;; make sure matching open brace isn't in a comment
+ (not (c-in-literal)))
+ (delete-region (point) (1- here)))
+ ;; clean up brace-else-brace
+ (if (and c-auto-newline
+ (memq 'brace-else-brace c-cleanup-list)
+ (eq last-command-char ?\{)
+ (re-search-backward "}[ \t\n]*else[ \t\n]*{" nil t)
+ (progn
+ (setq mbeg (match-beginning 0)
+ mend (match-end 0))
+ (= mend here))
+ (not (c-in-literal)))
+ (progn
+ (delete-region mbeg mend)
+ (insert "} else {")))
+ ;; clean up brace-elseif-brace
+ (if (and c-auto-newline
+ (memq 'brace-elseif-brace c-cleanup-list)
+ (eq last-command-char ?\{)
+ (re-search-backward "}[ \t\n]*else[ \t\n]+if[ \t\n]*" nil t)
+ (save-excursion
+ (goto-char (match-end 0))
+ (c-safe (forward-sexp 1))
+ (skip-chars-forward " \t\n")
+ (setq mbeg (match-beginning 0)
+ mend (match-end 0))
+ (= here (1+ (point))))
+ (not (c-in-literal)))
+ (progn
+ (delete-region mbeg mend)
+ (insert "} else if ")))
+ (goto-char (- (point-max) pos))
+ )
+ ;; does a newline go after the brace?
+ (if (memq 'after newlines)
+ (progn
+ (newline)
+ ;; update on c-state-cache
+ (let* ((bufpos (- (point) 2))
+ (which (if (eq (char-after bufpos) ?{) 'open 'close))
+ (c-state-cache (c-hack-state bufpos which c-state-cache)))
+ (c-indent-line))))
+ ;; blink the paren
+ (and (eq last-command-char ?\})
+ old-blink-paren
+ (save-excursion
+ (c-backward-syntactic-ws safepos)
+ (funcall old-blink-paren)))
+ ))))
+
+(defun c-electric-slash (arg)
+ "Insert a slash character.
+If slash is second of a double-slash C++ style comment introducing
+construct, and we are on a comment-only-line, indent line as comment.
+If numeric ARG is supplied or point is inside a literal, indentation
+is inhibited."
+ (interactive "P")
+ (let ((indentp (and (not arg)
+ (eq (char-before) ?/)
+ (eq last-command-char ?/)
+ (not (c-in-literal))))
+ ;; shut this up
+ (c-echo-syntactic-information-p nil))
+ (self-insert-command (prefix-numeric-value arg))
+ (if indentp
+ (c-indent-line))))
+
+(defun c-electric-star (arg)
+ "Insert a star character.
+If the star is the second character of a C style comment introducing
+construct, and we are on a comment-only-line, indent line as comment.
+If numeric ARG is supplied or point is inside a literal, indentation
+is inhibited."
+ (interactive "P")
+ (self-insert-command (prefix-numeric-value arg))
+ ;; if we are in a literal, or if arg is given do not re-indent the
+ ;; current line, unless this star introduces a comment-only line.
+ (if (and (not arg)
+ (memq (c-in-literal) '(c))
+ (eq (char-before) ?*)
+ (save-excursion
+ (forward-char -1)
+ (skip-chars-backward "*")
+ (if (eq (char-before) ?/)
+ (forward-char -1))
+ (skip-chars-backward " \t")
+ (bolp)))
+ ;; shut this up
+ (let (c-echo-syntactic-information-p)
+ (c-indent-line))
+ ))
+
+(defun c-electric-semi&comma (arg)
+ "Insert a comma or semicolon.
+When the auto-newline feature is turned on, as evidenced by the \"/a\"
+or \"/ah\" string on the mode line, a newline might be inserted. See
+the variable `c-hanging-semi&comma-criteria' for how newline insertion
+is determined.
+
+When semicolon is inserted, the line is re-indented unless a numeric
+arg is supplied, point is inside a literal, or there are
+non-whitespace characters on the line following the semicolon."
+ (interactive "P")
+ (let* ((lim (c-most-enclosing-brace (c-parse-state)))
+ (literal (c-in-literal lim))
+ (here (point))
+ ;; shut this up
+ (c-echo-syntactic-information-p nil))
+ (if (or literal
+ arg
+ (not (looking-at "[ \t]*$")))
+ (self-insert-command (prefix-numeric-value arg))
+ ;; do some special stuff with the character
+ (self-insert-command (prefix-numeric-value arg))
+ ;; do all cleanups, reindentations, and newline insertions, but
+ ;; only if c-auto-newline is turned on
+ (if (not c-auto-newline) nil
+ ;; clean ups
+ (let ((pos (- (point-max) (point))))
+ (if (and (or (and
+ (eq last-command-char ?,)
+ (memq 'list-close-comma c-cleanup-list))
+ (and
+ (eq last-command-char ?\;)
+ (memq 'defun-close-semi c-cleanup-list)))
+ (progn
+ (forward-char -1)
+ (skip-chars-backward " \t\n")
+ (eq (char-before) ?}))
+ ;; make sure matching open brace isn't in a comment
+ (not (c-in-literal lim)))
+ (delete-region (point) here))
+ (goto-char (- (point-max) pos)))
+ ;; re-indent line
+ (c-indent-line)
+ ;; check to see if a newline should be added
+ (let ((criteria c-hanging-semi&comma-criteria)
+ answer add-newline-p)
+ (while criteria
+ (setq answer (funcall (car criteria)))
+ ;; only nil value means continue checking
+ (if (not answer)
+ (setq criteria (cdr criteria))
+ (setq criteria nil)
+ ;; only 'stop specifically says do not add a newline
+ (setq add-newline-p (not (eq answer 'stop)))
+ ))
+ (if add-newline-p
+ (progn (newline)
+ (c-indent-line)))
+ )))))
+
+(defun c-electric-colon (arg)
+ "Insert a colon.
+
+If the auto-newline feature is turned on, as evidenced by the \"/a\"
+or \"/ah\" string on the mode line, newlines are inserted before and
+after colons based on the value of `c-hanging-colons-alist'.
+
+Also, the line is re-indented unless a numeric ARG is supplied, there
+are non-whitespace characters present on the line after the colon, or
+the colon is inserted inside a literal.
+
+This function cleans up double colon scope operators based on the
+value of `c-cleanup-list'."
+ (interactive "P")
+ (let* ((bod (c-point 'bod))
+ (literal (c-in-literal bod))
+ syntax newlines
+ ;; shut this up
+ (c-echo-syntactic-information-p nil))
+ (if (or literal
+ arg
+ (not (looking-at "[ \t]*$")))
+ (self-insert-command (prefix-numeric-value arg))
+ ;; insert the colon, then do any specified cleanups
+ (self-insert-command (prefix-numeric-value arg))
+ (let ((pos (- (point-max) (point)))
+ (here (point)))
+ (if (and c-auto-newline
+ (memq 'scope-operator c-cleanup-list)
+ (eq (char-before) ?:)
+ (progn
+ (forward-char -1)
+ (skip-chars-backward " \t\n")
+ (eq (char-before) ?:))
+ (not (c-in-literal))
+ (not (eq (char-after (- (point) 2)) ?:)))
+ (delete-region (point) (1- here)))
+ (goto-char (- (point-max) pos)))
+ ;; lets do some special stuff with the colon character
+ (setq syntax (c-guess-basic-syntax)
+ ;; some language elements can only be determined by
+ ;; checking the following line. Lets first look for ones
+ ;; that can be found when looking on the line with the
+ ;; colon
+ newlines
+ (and c-auto-newline
+ (or (c-lookup-lists '(case-label label access-label)
+ syntax c-hanging-colons-alist)
+ (c-lookup-lists '(member-init-intro inher-intro)
+ (prog2
+ (insert "\n")
+ (c-guess-basic-syntax)
+ (delete-char -1))
+ c-hanging-colons-alist))))
+ ;; indent the current line
+ (c-indent-line syntax)
+ ;; does a newline go before the colon? Watch out for already
+ ;; non-hung colons. However, we don't unhang them because that
+ ;; would be a cleanup (and anti-social).
+ (if (and (memq 'before newlines)
+ (save-excursion
+ (skip-chars-backward ": \t")
+ (not (bolp))))
+ (let ((pos (- (point-max) (point))))
+ (forward-char -1)
+ (newline)
+ (c-indent-line)
+ (goto-char (- (point-max) pos))))
+ ;; does a newline go after the colon?
+ (if (memq 'after (cdr-safe newlines))
+ (progn
+ (newline)
+ (c-indent-line)))
+ )))
+
+(defun c-electric-lt-gt (arg)
+ "Insert a less-than, or greater-than character.
+When the auto-newline feature is turned on, as evidenced by the \"/a\"
+or \"/ah\" string on the mode line, the line will be re-indented if
+the character inserted is the second of a C++ style stream operator
+and the buffer is in C++ mode.
+
+The line will also not be re-indented if a numeric argument is
+supplied, or point is inside a literal."
+ (interactive "P")
+ (let ((indentp (and (not arg)
+ (eq (char-before) last-command-char)
+ (not (c-in-literal))))
+ ;; shut this up
+ (c-echo-syntactic-information-p nil))
+ (self-insert-command (prefix-numeric-value arg))
+ (if indentp
+ (c-indent-line))))
+
+
+\f
+;; better movement routines for ThisStyleOfVariablesCommonInCPlusPlus
+;; originally contributed by Terry_Glanfield.Southern@rxuk.xerox.com
+(defun c-forward-into-nomenclature (&optional arg)
+ "Move forward to end of a nomenclature section or word.
+With arg, to it arg times."
+ (interactive "p")
+ (let ((case-fold-search nil))
+ (if (> arg 0)
+ (re-search-forward "\\W*\\([A-Z]*[a-z0-9]*\\)" (point-max) t arg)
+ (while (and (< arg 0)
+ (re-search-backward
+ "\\(\\(\\W\\|[a-z0-9]\\)[A-Z]+\\|\\W\\w+\\)"
+ (point-min) 0))
+ (forward-char 1)
+ (setq arg (1+ arg)))))
+ (c-keep-region-active))
+
+(defun c-backward-into-nomenclature (&optional arg)
+ "Move backward to beginning of a nomenclature section or word.
+With optional ARG, move that many times. If ARG is negative, move
+forward."
+ (interactive "p")
+ (c-forward-into-nomenclature (- arg))
+ (c-keep-region-active))
+
+(defun c-scope-operator ()
+ "Insert a double colon scope operator at point.
+No indentation or other \"electric\" behavior is performed."
+ (interactive)
+ (insert "::"))
+
+\f
+(defun c-beginning-of-statement (&optional count lim sentence-flag)
+ "Go to the beginning of the innermost C statement.
+With prefix arg, go back N - 1 statements. If already at the
+beginning of a statement then go to the beginning of the preceding
+one. If within a string or comment, or next to a comment (only
+whitespace between), move by sentences instead of statements.
+
+When called from a program, this function takes 3 optional args: the
+repetition count, a buffer position limit which is the farthest back
+to search, and a flag saying whether to do sentence motion when in a
+comment."
+ (interactive (list (prefix-numeric-value current-prefix-arg)
+ nil t))
+ (let ((here (point))
+ (count (or count 1))
+ (lim (or lim (c-point 'bod)))
+ state)
+ (save-excursion
+ (goto-char lim)
+ (setq state (parse-partial-sexp (point) here nil nil)))
+ (if (and sentence-flag
+ (or (nth 3 state)
+ (nth 4 state)
+; (looking-at (concat "[ \t]*" comment-start-skip))
+ (save-excursion
+ (skip-chars-backward " \t")
+ (goto-char (- (point) 2))
+ (looking-at "\\*/"))))
+ (forward-sentence (- count))
+ (while (> count 0)
+ (c-beginning-of-statement-1 lim)
+ (setq count (1- count)))
+ (while (< count 0)
+ (c-end-of-statement-1)
+ (setq count (1+ count))))
+ ;; its possible we've been left up-buf of lim
+ (goto-char (max (point) lim))
+ )
+ (c-keep-region-active))
+
+(defun c-end-of-statement (&optional count lim sentence-flag)
+ "Go to the end of the innermost C statement.
+
+With prefix arg, go forward N - 1 statements. Move forward to end of
+the next statement if already at end. If within a string or comment,
+move by sentences instead of statements.
+
+When called from a program, this function takes 3 optional args: the
+repetition count, a buffer position limit which is the farthest back
+to search, and a flag saying whether to do sentence motion when in a
+comment."
+ (interactive (list (prefix-numeric-value current-prefix-arg)
+ nil t))
+ (c-beginning-of-statement (- (or count 1)) lim sentence-flag)
+ (c-keep-region-active))
+
+\f
+;; set up electric character functions to work with pending-del,
+;; (a.k.a. delsel) mode. All symbols get the t value except
+;; c-electric-delete which gets 'supersede.
+(mapcar
+ (function
+ (lambda (sym)
+ (put sym 'delete-selection t) ; for delsel (Emacs)
+ (put sym 'pending-delete t))) ; for pending-del (XEmacs)
+ '(c-electric-pound
+ c-electric-brace
+ c-electric-slash
+ c-electric-star
+ c-electric-semi&comma
+ c-electric-lt-gt
+ c-electric-colon))
+(put 'c-electric-delete 'delete-selection 'supersede) ; delsel
+(put 'c-electric-delete 'pending-delete 'supersede) ; pending-del
+
+\f
+;; This is used by indent-for-comment to decide how much to indent a
+;; comment in C code based on its context.
+(defun c-comment-indent ()
+ (if (looking-at (concat "^\\(" c-comment-start-regexp "\\)"))
+ 0 ;Existing comment at bol stays there.
+ (let ((opoint (point))
+ placeholder)
+ (save-excursion
+ (beginning-of-line)
+ (cond
+ ;; CASE 1: A comment following a solitary close-brace should
+ ;; have only one space.
+ ((looking-at (concat "[ \t]*}[ \t]*\\($\\|"
+ c-comment-start-regexp
+ "\\)"))
+ (search-forward "}")
+ (1+ (current-column)))
+ ;; CASE 2: 2 spaces after #endif
+ ((or (looking-at "^#[ \t]*endif[ \t]*")
+ (looking-at "^#[ \t]*else[ \t]*"))
+ 7)
+ ;; CASE 3: when comment-column is nil, calculate the offset
+ ;; according to c-offsets-alist. E.g. identical to hitting
+ ;; TAB.
+ ((and c-indent-comments-syntactically-p
+ (save-excursion
+ (skip-chars-forward " \t")
+ (or (looking-at comment-start)
+ (eolp))))
+ (let ((syntax (c-guess-basic-syntax)))
+ ;; BOGOSITY ALERT: if we're looking at the eol, its
+ ;; because indent-for-comment hasn't put the comment-start
+ ;; in the buffer yet. this will screw up the syntactic
+ ;; analysis so we kludge in the necessary info. Another
+ ;; kludge is that if we're at the bol, then we really want
+ ;; to ignore any anchoring as specified by
+ ;; c-comment-only-line-offset since it doesn't apply here.
+ (if (save-excursion
+ (beginning-of-line)
+ (skip-chars-forward " \t")
+ (eolp))
+ (c-add-syntax 'comment-intro))
+ (let ((c-comment-only-line-offset
+ (if (consp c-comment-only-line-offset)
+ c-comment-only-line-offset
+ (cons c-comment-only-line-offset
+ c-comment-only-line-offset))))
+ (apply '+ (mapcar 'c-get-offset syntax)))))
+ ;; CASE 4: use comment-column if previous line is a
+ ;; comment-only line indented to the left of comment-column
+ ((save-excursion
+ (beginning-of-line)
+ (and (not (bobp))
+ (forward-line -1))
+ (skip-chars-forward " \t")
+ (prog1
+ (looking-at c-comment-start-regexp)
+ (setq placeholder (point))))
+ (goto-char placeholder)
+ (if (< (current-column) comment-column)
+ comment-column
+ (current-column)))
+ ;; CASE 5: If comment-column is 0, and nothing but space
+ ;; before the comment, align it at 0 rather than 1.
+ ((progn
+ (goto-char opoint)
+ (skip-chars-backward " \t")
+ (and (= comment-column 0) (bolp)))
+ 0)
+ ;; CASE 6: indent at comment column except leave at least one
+ ;; space.
+ (t (max (1+ (current-column))
+ comment-column))
+ )))))
+
+;; used by outline-minor-mode
+(defun c-outline-level ()
+ (save-excursion
+ (skip-chars-forward "\t ")
+ (current-column)))
+
+\f
+(defun c-up-conditional (count)
+ "Move back to the containing preprocessor conditional, leaving mark behind.
+A prefix argument acts as a repeat count. With a negative argument,
+move forward to the end of the containing preprocessor conditional.
+When going backwards, `#elif' is treated like `#else' followed by
+`#if'. When going forwards, `#elif' is ignored."
+ (interactive "p")
+ (c-forward-conditional (- count) t)
+ (c-keep-region-active))
+
+(defun c-backward-conditional (count &optional up-flag)
+ "Move back across a preprocessor conditional, leaving mark behind.
+A prefix argument acts as a repeat count. With a negative argument,
+move forward across a preprocessor conditional."
+ (interactive "p")
+ (c-forward-conditional (- count) up-flag)
+ (c-keep-region-active))
+
+(defun c-forward-conditional (count &optional up-flag)
+ "Move forward across a preprocessor conditional, leaving mark behind.
+A prefix argument acts as a repeat count. With a negative argument,
+move backward across a preprocessor conditional."
+ (interactive "p")
+ (let* ((forward (> count 0))
+ (increment (if forward -1 1))
+ (search-function (if forward 're-search-forward 're-search-backward))
+ (new))
+ (save-excursion
+ (while (/= count 0)
+ (let ((depth (if up-flag 0 -1)) found)
+ (save-excursion
+ ;; Find the "next" significant line in the proper direction.
+ (while (and (not found)
+ ;; Rather than searching for a # sign that
+ ;; comes at the beginning of a line aside from
+ ;; whitespace, search first for a string
+ ;; starting with # sign. Then verify what
+ ;; precedes it. This is faster on account of
+ ;; the fastmap feature of the regexp matcher.
+ (funcall search-function
+ "#[ \t]*\\(if\\|elif\\|endif\\)"
+ nil t))
+ (beginning-of-line)
+ ;; Now verify it is really a preproc line.
+ (if (looking-at "^[ \t]*#[ \t]*\\(if\\|elif\\|endif\\)")
+ (let ((prev depth))
+ ;; Update depth according to what we found.
+ (beginning-of-line)
+ (cond ((looking-at "[ \t]*#[ \t]*endif")
+ (setq depth (+ depth increment)))
+ ((looking-at "[ \t]*#[ \t]*elif")
+ (if (and forward (= depth 0))
+ (setq found (point))))
+ (t (setq depth (- depth increment))))
+ ;; If we are trying to move across, and we find an
+ ;; end before we find a beginning, get an error.
+ (if (and (< prev 0) (< depth prev))
+ (error (if forward
+ "No following conditional at this level"
+ "No previous conditional at this level")))
+ ;; When searching forward, start from next line so
+ ;; that we don't find the same line again.
+ (if forward (forward-line 1))
+ ;; If this line exits a level of conditional, exit
+ ;; inner loop.
+ (if (< depth 0)
+ (setq found (point))))
+ ;; else
+ (if forward (forward-line 1))
+ )))
+ (or found
+ (error "No containing preprocessor conditional"))
+ (goto-char (setq new found)))
+ (setq count (+ count increment))))
+ (push-mark)
+ (goto-char new))
+ (c-keep-region-active))
+
+\f
+;; commands to indent lines, regions, defuns, and expressions
+(defun c-indent-command (&optional whole-exp)
+ "Indent current line as C code, and/or insert some whitespace.
+
+If `c-tab-always-indent' is t, always just indent the current line.
+If nil, indent the current line only if point is at the left margin or
+in the line's indentation; otherwise insert some whitespace[*]. If
+other than nil or t, then some whitespace[*] is inserted only within
+literals (comments and strings) and inside preprocessor directives,
+but the line is always reindented.
+
+A numeric argument, regardless of its value, means indent rigidly all
+the lines of the expression starting after point so that this line
+becomes properly indented. The relative indentation among the lines
+of the expression are preserved.
+
+ [*] The amount and kind of whitespace inserted is controlled by the
+ variable `c-insert-tab-function', which is called to do the actual
+ insertion of whitespace. Normally the function in this variable
+ just inserts a tab character, or the equivalent number of spaces,
+ depending on the variable `indent-tabs-mode'."
+
+ (interactive "P")
+ (let ((bod (c-point 'bod)))
+ (if whole-exp
+ ;; If arg, always indent this line as C
+ ;; and shift remaining lines of expression the same amount.
+ (let ((shift-amt (c-indent-line))
+ beg end)
+ (save-excursion
+ (if (eq c-tab-always-indent t)
+ (beginning-of-line))
+ (setq beg (point))
+ (forward-sexp 1)
+ (setq end (point))
+ (goto-char beg)
+ (forward-line 1)
+ (setq beg (point)))
+ (if (> end beg)
+ (indent-code-rigidly beg end (- shift-amt) "#")))
+ ;; No arg supplied, use c-tab-always-indent to determine
+ ;; behavior
+ (cond
+ ;; CASE 1: indent when at column zero or in lines indentation,
+ ;; otherwise insert a tab
+ ((not c-tab-always-indent)
+ (if (save-excursion
+ (skip-chars-backward " \t")
+ (not (bolp)))
+ (funcall c-insert-tab-function)
+ (c-indent-line)))
+ ;; CASE 2: just indent the line
+ ((eq c-tab-always-indent t)
+ (c-indent-line))
+ ;; CASE 3: if in a literal, insert a tab, but always indent the
+ ;; line
+ (t
+ (if (c-in-literal bod)
+ (funcall c-insert-tab-function))
+ (c-indent-line)
+ )))))
+
+(defun c-indent-exp (&optional shutup-p)
+ "Indent each line in balanced expression following point.
+Optional SHUTUP-P if non-nil, inhibits message printing and error checking."
+ (interactive "P")
+ (let ((here (point))
+ end progress-p)
+ (unwind-protect
+ (let ((c-echo-syntactic-information-p nil) ;keep quiet for speed
+ (start (progn
+ ;; try to be smarter about finding the range of
+ ;; lines to indent. skip all following
+ ;; whitespace. failing that, try to find any
+ ;; opening brace on the current line
+ (skip-chars-forward " \t\n")
+ (if (memq (char-after) '(?\( ?\[ ?\{))
+ (point)
+ (let ((state (parse-partial-sexp (point)
+ (c-point 'eol))))
+ (and (nth 1 state)
+ (goto-char (nth 1 state))
+ (memq (char-after) '(?\( ?\[ ?\{))
+ (point)))))))
+ ;; find balanced expression end
+ (setq end (and (c-safe (progn (forward-sexp 1) t))
+ (point-marker)))
+ ;; sanity check
+ (and (not start)
+ (not shutup-p)
+ (error "Cannot find start of balanced expression to indent."))
+ (and (not end)
+ (not shutup-p)
+ (error "Cannot find end of balanced expression to indent."))
+ (c-progress-init start end 'c-indent-exp)
+ (setq progress-p t)
+ (goto-char start)
+ (beginning-of-line)
+ (while (< (point) end)
+ (if (not (looking-at "[ \t]*$"))
+ (c-indent-line))
+ (c-progress-update)
+ (forward-line 1)))
+ ;; make sure marker is deleted
+ (and end
+ (set-marker end nil))
+ (and progress-p
+ (c-progress-fini 'c-indent-exp))
+ (goto-char here))))
+
+(defun c-indent-defun ()
+ "Re-indents the current top-level function def, struct or class declaration."
+ (interactive)
+ (let ((here (point-marker))
+ (c-echo-syntactic-information-p nil)
+ (brace (c-least-enclosing-brace (c-parse-state))))
+ (if brace
+ (goto-char brace)
+ (beginning-of-defun))
+ ;; if we're sitting at b-o-b, it might be because there was no
+ ;; least enclosing brace and we were sitting on the defun's open
+ ;; brace.
+ (if (and (bobp) (not (eq (char-after) ?\{)))
+ (goto-char here))
+ ;; if defun-prompt-regexp is non-nil, b-o-d might not leave us at
+ ;; the open brace. I consider this an Emacs bug.
+ (and (boundp 'defun-prompt-regexp)
+ defun-prompt-regexp
+ (looking-at defun-prompt-regexp)
+ (goto-char (match-end 0)))
+ ;; catch all errors in c-indent-exp so we can 1. give more
+ ;; meaningful error message, and 2. restore point
+ (unwind-protect
+ (c-indent-exp)
+ (goto-char here)
+ (set-marker here nil))))
+
+(defun c-indent-region (start end)
+ ;; Indent every line whose first char is between START and END inclusive.
+ (save-excursion
+ (goto-char start)
+ ;; Advance to first nonblank line.
+ (skip-chars-forward " \t\n")
+ (beginning-of-line)
+ (let (endmark)
+ (unwind-protect
+ (let ((c-tab-always-indent t)
+ ;; shut up any echo msgs on indiv lines
+ (c-echo-syntactic-information-p nil)
+ fence)
+ (c-progress-init start end 'c-indent-region)
+ (setq endmark (copy-marker end))
+ (while (and (bolp)
+ (not (eobp))
+ (< (point) endmark))
+ ;; update progress
+ (c-progress-update)
+ ;; Indent one line as with TAB.
+ (let (nextline sexpend sexpbeg)
+ ;; skip blank lines
+ (skip-chars-forward " \t\n")
+ (beginning-of-line)
+ ;; indent the current line
+ (c-indent-line)
+ (setq fence (point))
+ (if (save-excursion
+ (beginning-of-line)
+ (looking-at "[ \t]*#"))
+ (forward-line 1)
+ (save-excursion
+ ;; Find beginning of following line.
+ (setq nextline (c-point 'bonl))
+ ;; Find first beginning-of-sexp for sexp extending past
+ ;; this line.
+ (beginning-of-line)
+ (while (< (point) nextline)
+ (condition-case nil
+ (progn
+ (forward-sexp 1)
+ (setq sexpend (point)))
+ (error (setq sexpend nil)
+ (goto-char nextline)))
+ (c-forward-syntactic-ws))
+ (if sexpend
+ (progn
+ ;; make sure the sexp we found really starts on the
+ ;; current line and extends past it
+ (goto-char sexpend)
+ (setq sexpend (point-marker))
+ (c-safe (backward-sexp 1))
+ (setq sexpbeg (point))))
+ (if (and sexpbeg (< sexpbeg fence))
+ (setq sexpbeg fence)))
+ ;; check to see if the next line starts a
+ ;; comment-only line
+ (save-excursion
+ (forward-line 1)
+ (skip-chars-forward " \t")
+ (if (looking-at c-comment-start-regexp)
+ (setq sexpbeg (c-point 'bol))))
+ ;; If that sexp ends within the region, indent it all at
+ ;; once, fast.
+ (condition-case nil
+ (if (and sexpend
+ (> sexpend nextline)
+ (<= sexpend endmark))
+ (progn
+ (goto-char sexpbeg)
+ (c-indent-exp 'shutup)
+ (c-progress-update)
+ (goto-char sexpend)))
+ (error
+ (goto-char sexpbeg)
+ (c-indent-line)))
+ ;; Move to following line and try again.
+ (and sexpend
+ (markerp sexpend)
+ (set-marker sexpend nil))
+ (forward-line 1)
+ (setq fence (point))))))
+ (set-marker endmark nil)
+ (c-progress-fini 'c-indent-region)
+ (c-echo-parsing-error)
+ ))))
+
+(defun c-mark-function ()
+ "Put mark at end of a C, C++, or Objective-C defun, point at beginning."
+ (interactive)
+ (let ((here (point))
+ ;; there should be a c-point position for 'eod
+ (eod (save-excursion (end-of-defun) (point)))
+ (state (c-parse-state))
+ brace)
+ (while state
+ (setq brace (car state))
+ (if (consp brace)
+ (goto-char (cdr brace))
+ (goto-char brace))
+ (setq state (cdr state)))
+ (if (eq (char-after) ?{)
+ (progn
+ (forward-line -1)
+ (while (not (or (bobp)
+ (looking-at "[ \t]*$")))
+ (forward-line -1)))
+ (forward-line 1)
+ (skip-chars-forward " \t\n"))
+ (push-mark here)
+ (push-mark eod nil t)))
+
+\f
+;; for progress reporting
+(defvar c-progress-info nil)
+
+(defun c-progress-init (start end context)
+ ;; start the progress update messages. if this emacs doesn't have a
+ ;; built-in timer, just be dumb about it
+ (if (not (fboundp 'current-time))
+ (message "indenting region... (this may take a while)")
+ ;; if progress has already been initialized, do nothing. otherwise
+ ;; initialize the counter with a vector of:
+ ;; [start end lastsec context]
+ (if c-progress-info
+ ()
+ (setq c-progress-info (vector start
+ (save-excursion
+ (goto-char end)
+ (point-marker))
+ (nth 1 (current-time))
+ context))
+ (message "indenting region..."))))
+
+(defun c-progress-update ()
+ ;; update progress
+ (if (not (and c-progress-info c-progress-interval))
+ nil
+ (let ((now (nth 1 (current-time)))
+ (start (aref c-progress-info 0))
+ (end (aref c-progress-info 1))
+ (lastsecs (aref c-progress-info 2)))
+ ;; should we update? currently, update happens every 2 seconds,
+ ;; what's the right value?
+ (if (< c-progress-interval (- now lastsecs))
+ (progn
+ (message "indenting region... (%d%% complete)"
+ (/ (* 100 (- (point) start)) (- end start)))
+ (aset c-progress-info 2 now)))
+ )))
+
+(defun c-progress-fini (context)
+ ;; finished
+ (if (or (eq context (aref c-progress-info 3))
+ (eq context t))
+ (progn
+ (set-marker (aref c-progress-info 1) nil)
+ (setq c-progress-info nil)
+ (message "indenting region...done"))))
+
+
+\f
+;;; This page handles insertion and removal of backslashes for C macros.
+
+(defun c-backslash-region (from to delete-flag)
+ "Insert, align, or delete end-of-line backslashes on the lines in the region.
+With no argument, inserts backslashes and aligns existing backslashes.
+With an argument, deletes the backslashes.
+
+This function does not modify blank lines at the start of the region.
+If the region ends at the start of a line, it always deletes the
+backslash (if any) at the end of the previous line.
+
+You can put the region around an entire macro definition and use this
+command to conveniently insert and align the necessary backslashes."
+ (interactive "r\nP")
+ (save-excursion
+ (goto-char from)
+ (let ((column c-backslash-column)
+ (endmark (make-marker)))
+ (move-marker endmark to)
+ ;; Compute the smallest column number past the ends of all the lines.
+ (if (not delete-flag)
+ (while (< (point) to)
+ (end-of-line)
+ (if (eq (char-before) ?\\)
+ (progn (forward-char -1)
+ (skip-chars-backward " \t")))
+ (setq column (max column (1+ (current-column))))
+ (forward-line 1)))
+ ;; Adjust upward to a tab column, if that doesn't push past the margin.
+ (if (> (% column tab-width) 0)
+ (let ((adjusted (* (/ (+ column tab-width -1) tab-width) tab-width)))
+ (if (< adjusted (window-width))
+ (setq column adjusted))))
+ ;; Don't modify blank lines at start of region.
+ (goto-char from)
+ (while (and (< (point) endmark) (eolp))
+ (forward-line 1))
+ ;; Add or remove backslashes on all the lines.
+ (while (< (point) endmark)
+ (if (and (not delete-flag)
+ ;; Un-backslashify the last line
+ ;; if the region ends right at the start of the next line.
+ (save-excursion
+ (forward-line 1)
+ (< (point) endmark)))
+ (c-append-backslash column)
+ (c-delete-backslash))
+ (forward-line 1))
+ (move-marker endmark nil)))
+ (c-keep-region-active))
+
+(defun c-append-backslash (column)
+ (end-of-line)
+ (if (eq (char-before) ?\\)
+ (progn (forward-char -1)
+ (delete-horizontal-space)
+ (indent-to column))
+ (indent-to column)
+ (insert "\\")))
+
+(defun c-delete-backslash ()
+ (end-of-line)
+ (or (bolp)
+ (progn
+ (forward-char -1)
+ (if (looking-at "\\\\")
+ (delete-region (1+ (point))
+ (progn (skip-chars-backward " \t") (point)))))))
+
+\f
+(defun c-fill-paragraph (&optional arg)
+ "Like \\[fill-paragraph] but handles C and C++ style comments.
+If any of the current line is a comment or within a comment,
+fill the comment or the paragraph of it that point is in,
+preserving the comment indentation or line-starting decorations.
+
+Optional prefix ARG means justify paragraph as well."
+ (interactive "P")
+ (let* (comment-start-place
+ (first-line
+ ;; Check for obvious entry to comment.
+ (save-excursion
+ (beginning-of-line)
+ (skip-chars-forward " \t\n")
+ (and (looking-at comment-start-skip)
+ (setq comment-start-place (point)))))
+ (re1 "\\|[ \t]*/\\*[ \t]*$\\|[ \t]*\\*/[ \t]*$\\|[ \t/*]*$"))
+ (if (and c-double-slash-is-comments-p
+ (save-excursion
+ (beginning-of-line)
+ (looking-at ".*//")))
+ (let ((fill-prefix fill-prefix)
+ ;; Lines containing just a comment start or just an end
+ ;; should not be filled into paragraphs they are next
+ ;; to.
+ (paragraph-start (concat paragraph-start re1))
+ (paragraph-separate (concat paragraph-separate re1)))
+ (save-excursion
+ (beginning-of-line)
+ ;; Move up to first line of this comment.
+ (while (and (not (bobp))
+ (looking-at "[ \t]*//[ \t]*[^ \t\n]"))
+ (forward-line -1))
+ (if (not (looking-at ".*//[ \t]*[^ \t\n]"))
+ (forward-line 1))
+ ;; Find the comment start in this line.
+ (re-search-forward "[ \t]*//[ \t]*")
+ ;; Set the fill-prefix to be what all lines except the first
+ ;; should start with. But do not alter a user set fill-prefix.
+ (if (null fill-prefix)
+ (setq fill-prefix (buffer-substring (match-beginning 0)
+ (match-end 0))))
+ (save-restriction
+ ;; Narrow down to just the lines of this comment.
+ (narrow-to-region (c-point 'bol)
+ (save-excursion
+ (forward-line 1)
+ (while (looking-at fill-prefix)
+ (forward-line 1))
+ (point)))
+ (fill-paragraph arg)
+ t)))
+ ;; else C style comments
+ (if (or first-line
+ ;; t if we enter a comment between start of function and
+ ;; this line.
+ (eq (c-in-literal) 'c)
+ ;; t if this line contains a comment starter.
+ (setq first-line
+ (save-excursion
+ (beginning-of-line)
+ (prog1
+ (re-search-forward comment-start-skip
+ (save-excursion (end-of-line)
+ (point))
+ t)
+ (setq comment-start-place (point))))))
+ ;; Inside a comment: fill one comment paragraph.
+ (let ((fill-prefix
+ ;; The prefix for each line of this paragraph
+ ;; is the appropriate part of the start of this line,
+ ;; up to the column at which text should be indented.
+ (save-excursion
+ (beginning-of-line)
+ (if (looking-at "[ \t]*/\\*.*\\*/")
+ (progn (re-search-forward comment-start-skip)
+ (make-string (current-column) ?\ ))
+ (if first-line (forward-line 1))
+
+ (let ((line-width (progn (end-of-line) (current-column))))
+ (beginning-of-line)
+ (prog1
+ (buffer-substring
+ (point)
+
+ ;; How shall we decide where the end of the
+ ;; fill-prefix is?
+ (progn
+ (beginning-of-line)
+ (skip-chars-forward " \t*" (c-point 'eol))
+ ;; kludge alert, watch out for */, in
+ ;; which case fill-prefix should *not*
+ ;; be "*"!
+ (if (and (eq (char-after) ?/)
+ (eq (char-before) ?*))
+ (forward-char -1))
+ (point)))
+
+ ;; If the comment is only one line followed
+ ;; by a blank line, calling move-to-column
+ ;; above may have added some spaces and tabs
+ ;; to the end of the line; the fill-paragraph
+ ;; function will then delete it and the
+ ;; newline following it, so we'll lose a
+ ;; blank line when we shouldn't. So delete
+ ;; anything move-to-column added to the end
+ ;; of the line. We record the line width
+ ;; instead of the position of the old line
+ ;; end because move-to-column might break a
+ ;; tab into spaces, and the new characters
+ ;; introduced there shouldn't be deleted.
+
+ ;; If you can see a better way to do this,
+ ;; please make the change. This seems very
+ ;; messy to me.
+ (delete-region (progn (move-to-column line-width)
+ (point))
+ (progn (end-of-line) (point))))))))
+
+ ;; Lines containing just a comment start or just an end
+ ;; should not be filled into paragraphs they are next
+ ;; to.
+ (paragraph-start (concat paragraph-start re1))
+ (paragraph-separate (concat paragraph-separate re1))
+ (chars-to-delete 0)
+ )
+ (save-restriction
+ ;; Don't fill the comment together with the code
+ ;; following it. So temporarily exclude everything
+ ;; before the comment start, and everything after the
+ ;; line where the comment ends. If comment-start-place
+ ;; is non-nil, the comment starter is there. Otherwise,
+ ;; point is inside the comment.
+ (narrow-to-region (save-excursion
+ (if comment-start-place
+ (goto-char comment-start-place)
+ (search-backward "/*"))
+ (if (and (not c-hanging-comment-starter-p)
+ (looking-at
+ (concat c-comment-start-regexp
+ "[ \t]*$")))
+ (forward-line 1))
+ ;; Protect text before the comment
+ ;; start by excluding it. Add
+ ;; spaces to bring back proper
+ ;; indentation of that point.
+ (let ((column (current-column)))
+ (prog1 (point)
+ (setq chars-to-delete column)
+ (insert-char ?\ column))))
+ (save-excursion
+ (if comment-start-place
+ (goto-char (+ comment-start-place 2)))
+ (search-forward "*/" nil 'move)
+ (forward-line 1)
+ (point)))
+ (fill-paragraph arg)
+ (save-excursion
+ ;; Delete the chars we inserted to avoid clobbering
+ ;; the stuff before the comment start.
+ (goto-char (point-min))
+ (if (> chars-to-delete 0)
+ (delete-region (point) (+ (point) chars-to-delete)))
+ ;; Find the comment ender (should be on last line of
+ ;; buffer, given the narrowing) and don't leave it on
+ ;; its own line, unless that's the style that's desired.
+ (goto-char (point-max))
+ (forward-line -1)
+ (search-forward "*/" nil 'move)
+ (beginning-of-line)
+ (if (and c-hanging-comment-ender-p
+ (looking-at "[ \t]*\\*/"))
+ ;(delete-indentation)))))
+ (let ((fill-column (+ fill-column 9999)))
+ (forward-line -1)
+ (fill-region-as-paragraph (point) (point-max))))))
+ t)))))
+
+\f
+(provide 'cc-cmds)
+;;; cc-cmds.el ends here
--- /dev/null
+;;; cc-compat.el --- cc-mode compatibility with c-mode.el confusion
+
+;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
+
+;; Author: 1994-1997 Barry A. Warsaw
+;; Maintainer: cc-mode-help@python.org
+;; Created: August 1994, split from cc-mode.el
+;; Version: 5.12
+;; 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:
+;;
+;; Boring old c-mode.el (BOCM) is confusion and brain melt. cc-mode.el
+;; is clarity of thought and purity of chi. If you are still unwilling
+;; to accept enlightenment, this might help, or it may prolong your
+;; agony.
+;;
+;; To use, add the following to your c-mode-hook:
+;;
+;; (require 'cc-compat)
+;; (c-set-style "BOCM")
+
+;;; Code:
+
+(eval-when-compile
+ (require 'cc-styles)
+ (require 'cc-engine))
+
+\f
+;; In case c-mode.el isn't loaded
+(defvar c-indent-level 2
+ "*Indentation of C statements with respect to containing block.")
+(defvar c-brace-imaginary-offset 0
+ "*Imagined indentation of a C open brace that actually follows a statement.")
+(defvar c-brace-offset 0
+ "*Extra indentation for braces, compared with other text in same context.")
+(defvar c-argdecl-indent 5
+ "*Indentation level of declarations of C function arguments.")
+(defvar c-label-offset -2
+ "*Offset of C label lines and case statements relative to usual indentation.")
+(defvar c-continued-statement-offset 2
+ "*Extra indent for lines not starting new statements.")
+(defvar c-continued-brace-offset 0
+ "*Extra indent for substatements that start with open-braces.
+This is in addition to c-continued-statement-offset.")
+
+
+\f
+;; these offsets are taken by brute force testing c-mode.el, since
+;; there's no logic to what it does.
+(let* ((offsets '(c-offsets-alist .
+ ((defun-block-intro . cc-block-intro-offset)
+ (statement-block-intro . cc-block-intro-offset)
+ (defun-open . 0)
+ (class-open . 0)
+ (inline-open . c-brace-offset)
+ (block-open . c-brace-offset)
+ (block-close . cc-block-close-offset)
+ (brace-list-open . c-brace-offset)
+ (substatement-open . cc-substatement-open-offset)
+ (substatement . c-continued-statement-offset)
+ (knr-argdecl-intro . c-argdecl-indent)
+ (case-label . c-label-offset)
+ (access-label . c-label-offset)
+ (label . c-label-offset)
+ ))))
+ (c-add-style "BOCM" offsets))
+
+
+(defun cc-block-intro-offset (langelem)
+ ;; taken directly from calculate-c-indent confusion
+ (save-excursion
+ (c-backward-syntactic-ws)
+ (if (eq (char-before) ?{)
+ (forward-char -1)
+ (goto-char (cdr langelem)))
+ (let* ((curcol (save-excursion
+ (goto-char (cdr langelem))
+ (current-column)))
+ (bocm-lossage
+ ;; If no previous statement, indent it relative to line
+ ;; brace is on. For open brace in column zero, don't let
+ ;; statement start there too. If c-indent-level is zero,
+ ;; use c-brace-offset + c-continued-statement-offset
+ ;; instead. For open-braces not the first thing in a line,
+ ;; add in c-brace-imaginary-offset.
+ (+ (if (and (bolp) (zerop c-indent-level))
+ (+ c-brace-offset c-continued-statement-offset)
+ c-indent-level)
+ ;; Move back over whitespace before the openbrace. If
+ ;; openbrace is not first nonwhite thing on the line,
+ ;; add the c-brace-imaginary-offset.
+ (progn (skip-chars-backward " \t")
+ (if (bolp) 0 c-brace-imaginary-offset))
+ ;; If the openbrace is preceded by a parenthesized exp,
+ ;; move to the beginning of that; possibly a different
+ ;; line
+ (progn
+ (if (eq (char-before) ?\))
+ (forward-sexp -1))
+ ;; Get initial indentation of the line we are on.
+ (current-indentation)))))
+ (- bocm-lossage curcol))))
+
+
+(defun cc-block-close-offset (langelem)
+ (save-excursion
+ (let* ((here (point))
+ bracep
+ (curcol (progn
+ (goto-char (cdr langelem))
+ (current-column)))
+ (bocm-lossage (progn
+ (goto-char (cdr langelem))
+ (if (eq (char-after) ?{)
+ (setq bracep t)
+ (goto-char here)
+ (beginning-of-line)
+ (backward-up-list 1)
+ (forward-char 1)
+ (c-forward-syntactic-ws))
+ (current-column))))
+ (- bocm-lossage curcol
+ (if bracep 0 c-indent-level)))))
+
+
+(defun cc-substatement-open-offset (langelem)
+ (+ c-continued-statement-offset c-continued-brace-offset))
+
+\f
+(provide 'cc-compat)
+;;; cc-compat.el ends here
--- /dev/null
+;;; cc-defs.el --- definitions for CC Mode
+
+;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
+
+;; Authors: 1992-1997 Barry A. Warsaw
+;; 1987 Dave Detlefs and Stewart Clamen
+;; 1985 Richard M. Stallman
+;; Maintainer: cc-mode-help@python.org
+;; Created: 22-Apr-1997 (split from cc-mode.el)
+;; Version: 5.12
+;; 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.
+
+\f
+;; Figure out what features this Emacs has
+(defconst c-emacs-features
+ (let ((infodock-p (boundp 'infodock-version))
+ (comments
+ ;; XEmacs 19 and beyond use 8-bit modify-syntax-entry flags.
+ ;; Emacs 19 uses a 1-bit flag. We will have to set up our
+ ;; syntax tables differently to handle this.
+ (let ((table (copy-syntax-table))
+ entry)
+ (modify-syntax-entry ?a ". 12345678" table)
+ (cond
+ ;; XEmacs 19, and beyond Emacs 19.34
+ ((arrayp table)
+ (setq entry (aref table ?a))
+ ;; In Emacs, table entries are cons cells
+ (if (consp entry) (setq entry (car entry))))
+ ;; XEmacs 20
+ ((fboundp 'get-char-table) (setq entry (get-char-table ?a table)))
+ ;; before and including Emacs 19.34
+ ((and (fboundp 'char-table-p)
+ (char-table-p table))
+ (setq entry (car (char-table-range table [?a]))))
+ ;; incompatible
+ (t (error "CC Mode is incompatible with this version of Emacs")))
+ (if (= (logand (lsh entry -16) 255) 255)
+ '8-bit
+ '1-bit))))
+ (if infodock-p
+ (list comments 'infodock)
+ (list comments)))
+ "A list of features extant in the Emacs you are using.
+There are many flavors of Emacs out there, each with different
+features supporting those needed by CC Mode. Here's the current
+supported list, along with the values for this variable:
+
+ XEmacs 19: (8-bit)
+ XEmacs 20: (8-bit)
+ Emacs 19: (1-bit)
+
+Infodock (based on XEmacs) has an additional symbol on this list:
+'infodock.")
+
+
+\f
+(defsubst c-point (position)
+ ;; Returns the value of point at certain commonly referenced POSITIONs.
+ ;; POSITION can be one of the following symbols:
+ ;;
+ ;; bol -- beginning of line
+ ;; eol -- end of line
+ ;; bod -- beginning of defun
+ ;; boi -- back to indentation
+ ;; ionl -- indentation of next line
+ ;; iopl -- indentation of previous line
+ ;; bonl -- beginning of next line
+ ;; bopl -- beginning of previous line
+ ;;
+ ;; This function does not modify point or mark.
+ (let ((here (point)))
+ (cond
+ ((eq position 'bol) (beginning-of-line))
+ ((eq position 'eol) (end-of-line))
+ ((eq position 'bod)
+ (beginning-of-defun)
+ ;; if defun-prompt-regexp is non-nil, b-o-d won't leave us at
+ ;; the open brace.
+ (and defun-prompt-regexp
+ (looking-at defun-prompt-regexp)
+ (goto-char (match-end 0)))
+ )
+ ((eq position 'boi) (back-to-indentation))
+ ((eq position 'bonl) (forward-line 1))
+ ((eq position 'bopl) (forward-line -1))
+ ((eq position 'iopl)
+ (forward-line -1)
+ (back-to-indentation))
+ ((eq position 'ionl)
+ (forward-line 1)
+ (back-to-indentation))
+ (t (error "unknown buffer position requested: %s" position))
+ )
+ (prog1
+ (point)
+ (goto-char here))))
+
+(defmacro c-safe (&rest body)
+ ;; safely execute BODY, return nil if an error occurred
+ (` (condition-case nil
+ (progn (,@ body))
+ (error nil))))
+
+(defmacro c-add-syntax (symbol &optional relpos)
+ ;; a simple macro to append the syntax in symbol to the syntax list.
+ ;; try to increase performance by using this macro
+ (` (setq syntax (cons (cons (, symbol) (, relpos)) syntax))))
+
+(defsubst c-auto-newline ()
+ ;; if auto-newline feature is turned on, insert a newline character
+ ;; and return t, otherwise return nil.
+ (and c-auto-newline
+ (not (c-in-literal))
+ (not (newline))))
+
+(defsubst c-intersect-lists (list alist)
+ ;; return the element of ALIST that matches the first element found
+ ;; in LIST. Uses assq.
+ (let (match)
+ (while (and list
+ (not (setq match (assq (car list) alist))))
+ (setq list (cdr list)))
+ match))
+
+(defsubst c-lookup-lists (list alist1 alist2)
+ ;; first, find the first entry from LIST that is present in ALIST1,
+ ;; then find the entry in ALIST2 for that entry.
+ (assq (car (c-intersect-lists list alist1)) alist2))
+
+(defsubst c-langelem-col (langelem &optional preserve-point)
+ ;; convenience routine to return the column of langelem's relpos.
+ ;; Leaves point at the relpos unless preserve-point is non-nil.
+ (let ((here (point)))
+ (goto-char (cdr langelem))
+ (prog1 (current-column)
+ (if preserve-point
+ (goto-char here))
+ )))
+
+(defsubst c-update-modeline ()
+ ;; set the c-auto-hungry-string for the correct designation on the modeline
+ (setq c-auto-hungry-string
+ (if c-auto-newline
+ (if c-hungry-delete-key "/ah" "/a")
+ (if c-hungry-delete-key "/h" nil)))
+ (force-mode-line-update))
+
+(defsubst c-keep-region-active ()
+ ;; Do whatever is necessary to keep the region active in XEmacs.
+ ;; Ignore byte-compiler warnings you might see. This is not needed
+ ;; for Emacs.
+ (and (boundp 'zmacs-region-stays)
+ (setq zmacs-region-stays t)))
+
+(defsubst c-load-all ()
+ ;; make sure all necessary components of CC Mode are loaded in.
+ (require 'cc-vars)
+ (require 'cc-engine)
+ (require 'cc-langs)
+ (require 'cc-menus)
+ (require 'cc-align)
+ (require 'cc-styles)
+ (require 'cc-cmds))
+
+\f
+(provide 'cc-defs)
+;;; cc-defs.el ends here
--- /dev/null
+;;; cc-engine.el --- core syntax guessing engine for CC mode
+
+;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
+
+;; Authors: 1992-1997 Barry A. Warsaw
+;; 1987 Dave Detlefs and Stewart Clamen
+;; 1985 Richard M. Stallman
+;; Maintainer: cc-mode-help@python.org
+;; Created: 22-Apr-1997 (split from cc-mode.el)
+;; Version: 5.12
+;; 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.
+
+\f
+;; WARNING: Be *exceptionally* careful about modifications to this
+;; function! Much of CC Mode depends on this Doing The Right Thing.
+;; If you break it you will be sorry.
+
+(defun c-beginning-of-statement-1 (&optional lim)
+ ;; move to the start of the current statement, or the previous
+ ;; statement if already at the beginning of one.
+ (let ((firstp t)
+ (substmt-p t)
+ donep c-in-literal-cache
+ ;; KLUDGE ALERT: maybe-labelp is used to pass information
+ ;; between c-crosses-statement-barrier-p and
+ ;; c-beginning-of-statement-1. A better way should be
+ ;; implemented.
+ maybe-labelp saved
+ (last-begin (point)))
+ ;; first check for bare semicolon
+ (if (and (progn (c-backward-syntactic-ws lim)
+ (eq (char-before) ?\;))
+ (c-safe (progn (forward-char -1)
+ (setq saved (point))
+ t))
+ (progn (c-backward-syntactic-ws lim)
+ (memq (char-before) '(?\; ?{ ?} ?:)))
+ )
+ (setq last-begin saved)
+ (goto-char last-begin)
+ (while (not donep)
+ ;; stop at beginning of buffer
+ (if (bobp) (setq donep t)
+ ;; go backwards one balanced expression, but be careful of
+ ;; unbalanced paren being reached
+ (if (not (c-safe (progn (backward-sexp 1) t)))
+ (progn
+ (if firstp
+ (backward-up-list 1)
+ (goto-char last-begin))
+ ;; skip over any unary operators, or other special
+ ;; characters appearing at front of identifier
+ (save-excursion
+ (c-backward-syntactic-ws lim)
+ (skip-chars-backward "-+!*&:.~ \t\n")
+ (if (eq (char-before) ?\()
+ (setq last-begin (point))))
+ (goto-char last-begin)
+ (setq last-begin (point)
+ donep t)))
+
+ (setq maybe-labelp nil)
+ ;; see if we're in a literal. if not, then this bufpos may be
+ ;; a candidate for stopping
+ (cond
+ ;; CASE 0: did we hit the error condition above?
+ (donep)
+ ;; CASE 1: are we in a literal?
+ ((eq (c-in-literal lim) 'pound)
+ (beginning-of-line))
+ ;; CASE 2: some other kind of literal?
+ ((c-in-literal lim))
+ ;; CASE 3: are we looking at a conditional keyword?
+ ((or (looking-at c-conditional-key)
+ (and (eq (char-after) ?\()
+ (save-excursion
+ (forward-sexp 1)
+ (c-forward-syntactic-ws)
+ (not (eq (char-after) ?\;)))
+ (let ((here (point))
+ (foundp (progn
+ (c-backward-syntactic-ws lim)
+ (forward-word -1)
+ (and lim
+ (<= lim (point))
+ (not (c-in-literal lim))
+ (looking-at c-conditional-key)
+ ))))
+ ;; did we find a conditional?
+ (if (not foundp)
+ (goto-char here))
+ foundp)))
+ ;; are we in the middle of an else-if clause?
+ (if (save-excursion
+ (and (not substmt-p)
+ (c-safe (progn (forward-sexp -1) t))
+ (looking-at "\\<else\\>[ \t\n]+\\<if\\>")
+ (not (c-in-literal lim))))
+ (progn
+ (forward-sexp -1)
+ (c-backward-to-start-of-if lim)))
+ ;; are we sitting at an else clause, that we are not a
+ ;; substatement of?
+ (if (and (not substmt-p)
+ (looking-at "\\<else\\>[^_]"))
+ (c-backward-to-start-of-if lim))
+ ;; are we sitting at the while of a do-while?
+ (if (and (looking-at "\\<while\\>[^_]")
+ (c-backward-to-start-of-do lim))
+ (setq substmt-p nil))
+ (setq last-begin (point)
+ donep substmt-p))
+ ;; CASE 4: are we looking at a label?
+ ((looking-at c-label-key))
+ ;; CASE 5: is this the first time we're checking?
+ (firstp (setq firstp nil
+ substmt-p (not (c-crosses-statement-barrier-p
+ (point) last-begin))
+ last-begin (point)))
+ ;; CASE 6: have we crossed a statement barrier?
+ ((c-crosses-statement-barrier-p (point) last-begin)
+ (setq donep t))
+ ;; CASE 7: ignore labels
+ ((and maybe-labelp
+ (or (and c-access-key (looking-at c-access-key))
+ ;; with switch labels, we have to go back further
+ ;; to try to pick up the case or default
+ ;; keyword. Potential bogosity alert: we assume
+ ;; `case' or `default' is first thing on line
+ (let ((here (point)))
+ (beginning-of-line)
+ (c-forward-syntactic-ws)
+ (if (looking-at c-switch-label-key)
+ t
+ (goto-char here)
+ nil))
+ (looking-at c-label-key))))
+ ;; CASE 8: ObjC or Java method def
+ ((and c-method-key
+ (setq last-begin (c-in-method-def-p)))
+ (setq donep t))
+ ;; CASE 9: nothing special
+ (t (setq last-begin (point)))
+ ))))
+ (goto-char last-begin)
+ ;; we always do want to skip over non-whitespace modifier
+ ;; characters that didn't get skipped above
+ (skip-chars-backward "-+!*&:.~" (c-point 'boi))))
+
+(defun c-end-of-statement-1 ()
+ (condition-case ()
+ (progn
+ (while (and (not (eobp))
+ (let ((beg (point)))
+ (forward-sexp 1)
+ (let ((end (point)))
+ (save-excursion
+ (goto-char beg)
+ (not (re-search-forward "[;{}]" end t)))))))
+ (re-search-backward "[;}]")
+ (forward-char 1))
+ (error
+ (let ((beg (point)))
+ (backward-up-list -1)
+ (let ((end (point)))
+ (goto-char beg)
+ (search-forward ";" end 'move))))))
+
+
+\f
+(defun c-crosses-statement-barrier-p (from to)
+ ;; Does buffer positions FROM to TO cross a C statement boundary?
+ (let ((here (point))
+ (lim from)
+ crossedp)
+ (condition-case ()
+ (progn
+ (goto-char from)
+ (while (and (not crossedp)
+ (< (point) to))
+ (skip-chars-forward "^;{}:" to)
+ (if (not (c-in-literal lim))
+ (progn
+ (if (memq (char-after) '(?\; ?{ ?}))
+ (setq crossedp t)
+ (if (eq (char-after) ?:)
+ (setq maybe-labelp t))
+ (forward-char 1))
+ (setq lim (point)))
+ (forward-char 1))))
+ (error (setq crossedp nil)))
+ (goto-char here)
+ crossedp))
+
+\f
+;; Skipping of "syntactic whitespace", defined as lexical whitespace,
+;; C and C++ style comments, and preprocessor directives. Search no
+;; farther back or forward than optional LIM. If LIM is omitted,
+;; `beginning-of-defun' is used for backward skipping, point-max is
+;; used for forward skipping.
+
+(defun c-forward-syntactic-ws (&optional lim)
+ ;; Forward skip of syntactic whitespace for Emacs 19.
+ (save-restriction
+ (let* ((lim (or lim (point-max)))
+ (here lim)
+ (hugenum (point-max)))
+ (narrow-to-region lim (point))
+ (while (/= here (point))
+ (setq here (point))
+ (forward-comment hugenum)
+ ;; skip preprocessor directives
+ (if (and (eq (char-after) ?#)
+ (= (c-point 'boi) (point)))
+ (end-of-line)
+ )))))
+
+(defun c-backward-syntactic-ws (&optional lim)
+ ;; Backward skip over syntactic whitespace for Emacs 19.
+ (save-restriction
+ (let* ((lim (or lim (c-point 'bod)))
+ (here lim)
+ (hugenum (- (point-max))))
+ (if (< lim (point))
+ (progn
+ (narrow-to-region lim (point))
+ (while (/= here (point))
+ (setq here (point))
+ (forward-comment hugenum)
+ (if (eq (c-in-literal lim) 'pound)
+ (beginning-of-line))
+ )))
+ )))
+
+\f
+;; Return `c' if in a C-style comment, `c++' if in a C++ style
+;; comment, `string' if in a string literal, `pound' if on a
+;; preprocessor line, or nil if not in a comment at all. Optional LIM
+;; is used as the backward limit of the search. If omitted, or nil,
+;; `beginning-of-defun' is used."
+
+(defun c-in-literal (&optional lim)
+ ;; Determine if point is in a C++ literal. we cache the last point
+ ;; calculated if the cache is enabled
+ (if (and (boundp 'c-in-literal-cache)
+ c-in-literal-cache
+ (= (point) (aref c-in-literal-cache 0)))
+ (aref c-in-literal-cache 1)
+ (let ((rtn (save-excursion
+ (let* ((lim (or lim (c-point 'bod)))
+ (here (point))
+ (state (parse-partial-sexp lim (point))))
+ (cond
+ ((nth 3 state) 'string)
+ ((nth 4 state) (if (nth 7 state) 'c++ 'c))
+ ((progn
+ (goto-char here)
+ (beginning-of-line)
+ (looking-at "[ \t]*#"))
+ 'pound)
+ (t nil))))))
+ ;; cache this result if the cache is enabled
+ (and (boundp 'c-in-literal-cache)
+ (setq c-in-literal-cache (vector (point) rtn)))
+ rtn)))
+
+\f
+;; utilities for moving and querying around syntactic elements
+(defvar c-parsing-error nil)
+
+(defun c-parse-state ()
+ ;; Finds and records all open parens between some important point
+ ;; earlier in the file and point.
+ ;;
+ ;; if there's a state cache, return it
+ (setq c-parsing-error nil)
+ (if (boundp 'c-state-cache) c-state-cache
+ (let* (at-bob
+ (pos (save-excursion
+ ;; go back 2 bods, but ignore any bogus positions
+ ;; returned by beginning-of-defun (i.e. open paren
+ ;; in column zero)
+ (let ((cnt 2))
+ (while (not (or at-bob (zerop cnt)))
+ (beginning-of-defun)
+ (if (eq (char-after) ?\{)
+ (setq cnt (1- cnt)))
+ (if (bobp)
+ (setq at-bob t))))
+ (point)))
+ (here (save-excursion
+ ;;(skip-chars-forward " \t}")
+ (point)))
+ (last-bod pos) (last-pos pos)
+ placeholder state sexp-end)
+ ;; cache last bod position
+ (while (catch 'backup-bod
+ (setq state nil)
+ (while (and pos (< pos here))
+ (setq last-pos pos)
+ (if (and (setq pos (c-safe (scan-lists pos 1 -1)))
+ (<= pos here))
+ (progn
+ (setq sexp-end (c-safe (scan-sexps (1- pos) 1)))
+ (if (and sexp-end
+ (<= sexp-end here))
+ ;; we want to record both the start and end
+ ;; of this sexp, but we only want to record
+ ;; the last-most of any of them before here
+ (progn
+ (if (eq (char-after (1- pos)) ?\{)
+ (setq state (cons (cons (1- pos) sexp-end)
+ (if (consp (car state))
+ (cdr state)
+ state))))
+ (setq pos sexp-end))
+ ;; we're contained in this sexp so put pos on
+ ;; front of list
+ (setq state (cons (1- pos) state))))
+ ;; something bad happened. check to see if we
+ ;; crossed an unbalanced close brace. if so, we
+ ;; didn't really find the right `important bufpos'
+ ;; so lets back up and try again
+ (if (and (not pos) (not at-bob)
+ (setq placeholder
+ (c-safe (scan-lists last-pos 1 1)))
+ ;;(char-after (1- placeholder))
+ (<= placeholder here)
+ (eq (char-after (1- placeholder)) ?\}))
+ (while t
+ (setq last-bod (c-safe (scan-lists last-bod -1 1)))
+ (if (not last-bod)
+ (progn
+ ;; bogus, but what can we do here?
+ (setq c-parsing-error (1- placeholder))
+ (throw 'backup-bod nil))
+ (setq at-bob (= last-bod (point-min))
+ pos last-bod)
+ (if (= (char-after last-bod) ?\{)
+ (throw 'backup-bod t)))
+ )) ;end-if
+ )) ;end-while
+ nil))
+ state)))
+
+(defun c-whack-state (bufpos state)
+ ;; whack off any state information that appears on STATE which lies
+ ;; after the bounds of BUFPOS.
+ (let (newstate car)
+ (while state
+ (setq car (car state)
+ state (cdr state))
+ (if (consp car)
+ ;; just check the car, because in a balanced brace
+ ;; expression, it must be impossible for the corresponding
+ ;; close brace to be before point, but the open brace to be
+ ;; after.
+ (if (<= bufpos (car car))
+ nil ; whack it off
+ ;; its possible that the open brace is before bufpos, but
+ ;; the close brace is after. In that case, convert this
+ ;; to a non-cons element.
+ (if (<= bufpos (cdr car))
+ (setq newstate (append newstate (list (car car))))
+ ;; we know that both the open and close braces are
+ ;; before bufpos, so we also know that everything else
+ ;; on state is before bufpos, so we can glom up the
+ ;; whole thing and exit.
+ (setq newstate (append newstate (list car) state)
+ state nil)))
+ (if (<= bufpos car)
+ nil ; whack it off
+ ;; it's before bufpos, so everything else should too
+ (setq newstate (append newstate (list car) state)
+ state nil))))
+ newstate))
+
+(defun c-hack-state (bufpos which state)
+ ;; Using BUFPOS buffer position, and WHICH (must be 'open or
+ ;; 'close), hack the c-parse-state STATE and return the results.
+ (if (eq which 'open)
+ (let ((car (car state)))
+ (if (or (null car)
+ (consp car)
+ (/= bufpos car))
+ (cons bufpos state)
+ state))
+ (if (not (eq which 'close))
+ (error "c-hack-state, bad argument: %s" which))
+ ;; 'close brace
+ (let ((car (car state))
+ (cdr (cdr state)))
+ (if (consp car)
+ (setq car (car cdr)
+ cdr (cdr cdr)))
+ ;; TBD: is this test relevant???
+ (if (consp car)
+ state ;on error, don't change
+ ;; watch out for balanced expr already on cdr of list
+ (cons (cons car bufpos)
+ (if (consp (car cdr))
+ (cdr cdr) cdr))
+ ))))
+
+(defun c-adjust-state (from to shift state)
+ ;; Adjust all points in state that lie in the region FROM..TO by
+ ;; SHIFT amount (as would be returned by c-indent-line).
+ (mapcar
+ (function
+ (lambda (e)
+ (if (consp e)
+ (let ((car (car e))
+ (cdr (cdr e)))
+ (if (and (<= from car) (< car to))
+ (setcar e (+ shift car)))
+ (if (and (<= from cdr) (< cdr to))
+ (setcdr e (+ shift cdr))))
+ (if (and (<= from e) (< e to))
+ (setq e (+ shift e))))
+ e))
+ state))
+
+\f
+(defun c-beginning-of-inheritance-list (&optional lim)
+ ;; Go to the first non-whitespace after the colon that starts a
+ ;; multiple inheritance introduction. Optional LIM is the farthest
+ ;; back we should search.
+ (let ((lim (or lim (c-point 'bod)))
+ (placeholder (progn
+ (back-to-indentation)
+ (point))))
+ (c-backward-syntactic-ws lim)
+ (while (and (> (point) lim)
+ (memq (char-before) '(?, ?:))
+ (progn
+ (beginning-of-line)
+ (setq placeholder (point))
+ (skip-chars-forward " \t")
+ (not (looking-at c-class-key))
+ ))
+ (c-backward-syntactic-ws lim))
+ (goto-char placeholder)
+ (skip-chars-forward "^:" (c-point 'eol))))
+
+(defun c-beginning-of-macro (&optional lim)
+ ;; Go to the beginning of the macro. Right now we don't support
+ ;; multi-line macros too well
+ (back-to-indentation))
+
+(defun c-in-method-def-p ()
+ ;; Return nil if we aren't in a method definition, otherwise the
+ ;; position of the initial [+-].
+ (save-excursion
+ (beginning-of-line)
+ (and c-method-key
+ (looking-at c-method-key)
+ (point))
+ ))
+
+(defun c-just-after-func-arglist-p (&optional containing)
+ ;; Return t if we are between a function's argument list closing
+ ;; paren and its opening brace. Note that the list close brace
+ ;; could be followed by a "const" specifier or a member init hanging
+ ;; colon. Optional CONTAINING is position of containing s-exp open
+ ;; brace. If not supplied, point is used as search start.
+ (save-excursion
+ (c-backward-syntactic-ws)
+ (let ((checkpoint (or containing (point))))
+ (goto-char checkpoint)
+ ;; could be looking at const specifier
+ (if (and (eq (char-before) ?t)
+ (forward-word -1)
+ (looking-at "\\<const\\>"))
+ (c-backward-syntactic-ws)
+ ;; otherwise, we could be looking at a hanging member init
+ ;; colon
+ (goto-char checkpoint)
+ (if (and (eq (char-before) ?:)
+ (progn
+ (forward-char -1)
+ (c-backward-syntactic-ws)
+ (looking-at "[ \t\n]*:\\([^:]+\\|$\\)")))
+ nil
+ (goto-char checkpoint))
+ )
+ (and (eq (char-before) ?\))
+ ;; check if we are looking at a method def
+ (or (not c-method-key)
+ (progn
+ (forward-sexp -1)
+ (forward-char -1)
+ (c-backward-syntactic-ws)
+ (not (or (memq (char-before) '(?- ?+))
+ ;; or a class category
+ (progn
+ (forward-sexp -2)
+ (looking-at c-class-key))
+ )))))
+ )))
+
+;; defuns to look backwards for things
+(defun c-backward-to-start-of-do (&optional lim)
+ ;; Move to the start of the last "unbalanced" do expression.
+ ;; Optional LIM is the farthest back to search. If none is found,
+ ;; nil is returned and point is left unchanged, otherwise t is returned.
+ (let ((do-level 1)
+ (case-fold-search nil)
+ (lim (or lim (c-point 'bod)))
+ (here (point))
+ foundp)
+ (while (not (zerop do-level))
+ ;; we protect this call because trying to execute this when the
+ ;; while is not associated with a do will throw an error
+ (condition-case nil
+ (progn
+ (backward-sexp 1)
+ (cond
+ ((memq (c-in-literal lim) '(c c++)))
+ ((looking-at "while\\b[^_]")
+ (setq do-level (1+ do-level)))
+ ((looking-at "do\\b[^_]")
+ (if (zerop (setq do-level (1- do-level)))
+ (setq foundp t)))
+ ((<= (point) lim)
+ (setq do-level 0)
+ (goto-char lim))))
+ (error
+ (goto-char lim)
+ (setq do-level 0))))
+ (if (not foundp)
+ (goto-char here))
+ foundp))
+
+(defun c-backward-to-start-of-if (&optional lim)
+ ;; Move to the start of the last "unbalanced" if and return t. If
+ ;; none is found, and we are looking at an if clause, nil is
+ ;; returned. If none is found and we are looking at an else clause,
+ ;; an error is thrown.
+ (let ((if-level 1)
+ (here (c-point 'bol))
+ (case-fold-search nil)
+ (lim (or lim (c-point 'bod)))
+ (at-if (looking-at "if\\b[^_]")))
+ (catch 'orphan-if
+ (while (and (not (bobp))
+ (not (zerop if-level)))
+ (c-backward-syntactic-ws)
+ (condition-case nil
+ (backward-sexp 1)
+ (error
+ (if at-if
+ (throw 'orphan-if nil)
+ (error "No matching `if' found for `else' on line %d."
+ (1+ (count-lines 1 here))))))
+ (cond
+ ((looking-at "else\\b[^_]")
+ (setq if-level (1+ if-level)))
+ ((looking-at "if\\b[^_]")
+ ;; check for else if... skip over
+ (let ((here (point)))
+ (c-safe (forward-sexp -1))
+ (if (looking-at "\\<else\\>[ \t]+\\<if\\>")
+ nil
+ (setq if-level (1- if-level))
+ (goto-char here))))
+ ((< (point) lim)
+ (setq if-level 0)
+ (goto-char lim))
+ ))
+ t)))
+
+(defun c-skip-conditional ()
+ ;; skip forward over conditional at point, including any predicate
+ ;; statements in parentheses. No error checking is performed.
+ (forward-sexp (cond
+ ;; else if()
+ ((looking-at "\\<else\\>[ \t]+\\<if\\>") 3)
+ ;; do, else, try, finally
+ ((looking-at "\\<\\(do\\|else\\|try\\|finally\\)\\>") 1)
+ ;; for, if, while, switch, catch, synchronized
+ (t 2))))
+
+(defun c-skip-case-statement-forward (state &optional lim)
+ ;; skip forward over case/default bodies, with optional maximal
+ ;; limit. if no next case body is found, nil is returned and point
+ ;; is not moved
+ (let ((lim (or lim (point-max)))
+ (here (point))
+ donep foundp bufpos
+ (safepos (point))
+ (balanced (car state)))
+ ;; search until we've passed the limit, or we've found our match
+ (while (and (< (point) lim)
+ (not donep))
+ (setq safepos (point))
+ ;; see if we can find a case statement, not in a literal
+ (if (and (re-search-forward c-switch-label-key lim 'move)
+ (setq bufpos (match-beginning 0))
+ (not (c-in-literal safepos))
+ (/= bufpos here))
+ ;; if we crossed into a balanced sexp, we know the case is
+ ;; not part of our switch statement, so just bound over the
+ ;; sexp and keep looking.
+ (if (and (consp balanced)
+ (> bufpos (car balanced))
+ (< bufpos (cdr balanced)))
+ (goto-char (cdr balanced))
+ (goto-char bufpos)
+ (setq donep t
+ foundp t))))
+ (if (not foundp)
+ (goto-char here))
+ foundp))
+
+(defun c-search-uplist-for-classkey (brace-state)
+ ;; search for the containing class, returning a 2 element vector if
+ ;; found. aref 0 contains the bufpos of the class key, and aref 1
+ ;; contains the bufpos of the open brace.
+ (if (null brace-state)
+ ;; no brace-state means we cannot be inside a class
+ nil
+ (let ((carcache (car brace-state))
+ search-start search-end)
+ (if (consp carcache)
+ ;; a cons cell in the first element means that there is some
+ ;; balanced sexp before the current bufpos. this we can
+ ;; ignore. the nth 1 and nth 2 elements define for us the
+ ;; search boundaries
+ (setq search-start (nth 2 brace-state)
+ search-end (nth 1 brace-state))
+ ;; if the car was not a cons cell then nth 0 and nth 1 define
+ ;; for us the search boundaries
+ (setq search-start (nth 1 brace-state)
+ search-end (nth 0 brace-state)))
+ ;; search-end cannot be a cons cell
+ (and (consp search-end)
+ (error "consp search-end: %s" search-end))
+ ;; if search-end is nil, or if the search-end character isn't an
+ ;; open brace, we are definitely not in a class
+ (if (or (not search-end)
+ (< search-end (point-min))
+ (not (eq (char-after search-end) ?{)))
+ nil
+ ;; now, we need to look more closely at search-start. if
+ ;; search-start is nil, then our start boundary is really
+ ;; point-min.
+ (if (not search-start)
+ (setq search-start (point-min))
+ ;; if search-start is a cons cell, then we can start
+ ;; searching from the end of the balanced sexp just ahead of
+ ;; us
+ (if (consp search-start)
+ (setq search-start (cdr search-start))))
+ ;; now we can do a quick regexp search from search-start to
+ ;; search-end and see if we can find a class key. watch for
+ ;; class like strings in literals
+ (save-excursion
+ (save-restriction
+ (goto-char search-start)
+ (let ((search-key (concat c-class-key "\\|extern[^_]"))
+ foundp class match-end)
+ (while (and (not foundp)
+ (progn
+ (c-forward-syntactic-ws)
+ (> search-end (point)))
+ (re-search-forward search-key search-end t))
+ (setq class (match-beginning 0)
+ match-end (match-end 0))
+ (if (c-in-literal search-start)
+ nil ; its in a comment or string, ignore
+ (goto-char class)
+ (skip-chars-forward " \t\n")
+ (setq foundp (vector (c-point 'boi) search-end))
+ (cond
+ ;; check for embedded keywords
+ ((let ((char (char-after (1- class))))
+ (and char
+ (memq (char-syntax char) '(?w ?_))))
+ (goto-char match-end)
+ (setq foundp nil))
+ ;; make sure we're really looking at the start of a
+ ;; class definition, and not a forward decl, return
+ ;; arg, template arg list, or an ObjC or Java method.
+ ((and c-method-key
+ (re-search-forward c-method-key search-end t))
+ (setq foundp nil))
+ ;; Its impossible to define a regexp for this, and
+ ;; nearly so to do it programmatically.
+ ;;
+ ;; ; picks up forward decls
+ ;; = picks up init lists
+ ;; ) picks up return types
+ ;; > picks up templates, but remember that we can
+ ;; inherit from templates!
+ ((let ((skipchars "^;=)"))
+ ;; try to see if we found the `class' keyword
+ ;; inside a template arg list
+ (save-excursion
+ (skip-chars-backward "^<>" search-start)
+ (if (eq (char-before) ?<)
+ (setq skipchars (concat skipchars ">"))))
+ (skip-chars-forward skipchars search-end)
+ (/= (point) search-end))
+ (setq foundp nil))
+ )))
+ foundp))
+ )))))
+
+(defun c-inside-bracelist-p (containing-sexp brace-state)
+ ;; return the buffer position of the beginning of the brace list
+ ;; statement if we're inside a brace list, otherwise return nil.
+ ;; CONTAINING-SEXP is the buffer pos of the innermost containing
+ ;; paren. BRACE-STATE is the remainder of the state of enclosing braces
+ ;;
+ ;; N.B.: This algorithm can potentially get confused by cpp macros
+ ;; places in inconvenient locations. Its a trade-off we make for
+ ;; speed.
+ (or
+ ;; this will pick up enum lists
+ (condition-case ()
+ (save-excursion
+ (goto-char containing-sexp)
+ (forward-sexp -1)
+ (if (or (looking-at "enum[\t\n ]+")
+ (progn (forward-sexp -1)
+ (looking-at "enum[\t\n ]+")))
+ (point)))
+ (error nil))
+ ;; this will pick up array/aggregate init lists, even if they are nested.
+ (save-excursion
+ (let (bufpos failedp)
+ (while (and (not bufpos)
+ containing-sexp)
+ (if (consp containing-sexp)
+ (setq containing-sexp (car brace-state)
+ brace-state (cdr brace-state))
+ ;; see if significant character just before brace is an equal
+ (goto-char containing-sexp)
+ (setq failedp nil)
+ (condition-case ()
+ (progn
+ (forward-sexp -1)
+ (forward-sexp 1)
+ (c-forward-syntactic-ws containing-sexp))
+ (error (setq failedp t)))
+ (if (or failedp (not (eq (char-after) ?=)))
+ ;; lets see if we're nested. find the most nested
+ ;; containing brace
+ (setq containing-sexp (car brace-state)
+ brace-state (cdr brace-state))
+ ;; we've hit the beginning of the aggregate list
+ (c-beginning-of-statement-1 (c-most-enclosing-brace brace-state))
+ (setq bufpos (point)))
+ ))
+ bufpos))
+ ))
+
+\f
+(defun c-most-enclosing-brace (state)
+ ;; return the bufpos of the most enclosing brace that hasn't been
+ ;; narrowed out by any enclosing class, or nil if none was found
+ (let (enclosingp)
+ (while (and state (not enclosingp))
+ (setq enclosingp (car state)
+ state (cdr state))
+ (if (consp enclosingp)
+ (setq enclosingp nil)
+ (if (> (point-min) enclosingp)
+ (setq enclosingp nil))
+ (setq state nil)))
+ enclosingp))
+
+(defun c-least-enclosing-brace (state)
+ ;; return the bufpos of the least (highest) enclosing brace that
+ ;; hasn't been narrowed out by any enclosing class, or nil if none
+ ;; was found.
+ (c-most-enclosing-brace (nreverse state)))
+
+(defun c-safe-position (bufpos state)
+ ;; return the closest known safe position higher up than point
+ (let ((safepos nil))
+ (while state
+ (setq safepos
+ (if (consp (car state))
+ (cdr (car state))
+ (car state)))
+ (if (< safepos bufpos)
+ (setq state nil)
+ (setq state (cdr state))))
+ safepos))
+
+(defun c-narrow-out-enclosing-class (state lim)
+ ;; narrow the buffer so that the enclosing class is hidden
+ (let (inclass-p)
+ (and state
+ (setq inclass-p (c-search-uplist-for-classkey state))
+ (narrow-to-region
+ (progn
+ (goto-char (1+ (aref inclass-p 1)))
+ (skip-chars-forward " \t\n" lim)
+ ;; if point is now left of the class opening brace, we're
+ ;; hosed, so try a different tact
+ (if (<= (point) (aref inclass-p 1))
+ (progn
+ (goto-char (1+ (aref inclass-p 1)))
+ (c-forward-syntactic-ws lim)))
+ (point))
+ ;; end point is the end of the current line
+ (progn
+ (goto-char lim)
+ (c-point 'eol))))
+ ;; return the class vector
+ inclass-p))
+
+\f
+;; This function implements the main decision tree for determining the
+;; syntactic analysis of the current line of code. Yes, it's huge and
+;; bloated!
+
+(defun c-guess-basic-syntax ()
+ (save-excursion
+ (save-restriction
+ (beginning-of-line)
+ (let* ((indent-point (point))
+ (case-fold-search nil)
+ (fullstate (c-parse-state))
+ (state fullstate)
+ (in-method-intro-p (and (eq major-mode 'objc-mode)
+ c-method-key
+ (looking-at c-method-key)))
+ literal containing-sexp char-before-ip char-after-ip lim
+ syntax placeholder c-in-literal-cache inswitch-p
+ injava-inher
+ ;; narrow out any enclosing class or extern "C" block
+ (inclass-p (c-narrow-out-enclosing-class state indent-point))
+ (inextern-p (and inclass-p
+ (save-excursion
+ (save-restriction
+ (widen)
+ (goto-char (aref inclass-p 0))
+ (looking-at "extern[^_]")))))
+ )
+
+ ;; get the buffer position of the most nested opening brace,
+ ;; if there is one, and it hasn't been narrowed out
+ (save-excursion
+ (goto-char indent-point)
+ (skip-chars-forward " \t}")
+ (skip-chars-backward " \t")
+ (while (and state
+ (not in-method-intro-p)
+ (not containing-sexp))
+ (setq containing-sexp (car state)
+ state (cdr state))
+ (if (consp containing-sexp)
+ ;; if cdr == point, then containing sexp is the brace
+ ;; that opens the sexp we close
+ (if (= (cdr containing-sexp) (point))
+ (setq containing-sexp (car containing-sexp))
+ ;; otherwise, ignore this element
+ (setq containing-sexp nil))
+ ;; ignore the bufpos if its been narrowed out by the
+ ;; containing class
+ (if (<= containing-sexp (point-min))
+ (setq containing-sexp nil)))))
+
+ ;; set the limit on the farthest back we need to search
+ (setq lim (or containing-sexp
+ (if (consp (car fullstate))
+ (cdr (car fullstate))
+ nil)
+ (point-min)))
+
+ ;; cache char before and after indent point, and move point to
+ ;; the most likely position to perform the majority of tests
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ (setq char-after-ip (char-after))
+ (c-backward-syntactic-ws lim)
+ (setq char-before-ip (char-before))
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+
+ ;; are we in a literal?
+ (setq literal (c-in-literal lim))
+
+ ;; now figure out syntactic qualities of the current line
+ (cond
+ ;; CASE 1: in a string.
+ ((memq literal '(string))
+ (c-add-syntax 'string (c-point 'bopl)))
+ ;; CASE 2: in a C or C++ style comment.
+ ((memq literal '(c c++))
+ ;; we need to catch multi-paragraph C comments
+ (while (and (zerop (forward-line -1))
+ (looking-at "^[ \t]*$")))
+ (c-add-syntax literal (c-point 'boi)))
+ ;; CASE 3: in a cpp preprocessor
+ ((eq literal 'pound)
+ (c-beginning-of-macro lim)
+ (c-add-syntax 'cpp-macro (c-point 'boi)))
+ ;; CASE 4: in an objective-c method intro
+ (in-method-intro-p
+ (c-add-syntax 'objc-method-intro (c-point 'boi)))
+ ;; CASE 5: Line is at top level.
+ ((null containing-sexp)
+ (cond
+ ;; CASE 5A: we are looking at a defun, class, or
+ ;; inline-inclass method opening brace
+ ((eq char-after-ip ?{)
+ (cond
+ ;; CASE 5A.1: extern declaration
+ ((save-excursion
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ (and (c-safe (progn (backward-sexp 2) t))
+ (looking-at "extern[^_]")
+ (progn
+ (setq placeholder (point))
+ (forward-sexp 1)
+ (c-forward-syntactic-ws)
+ (eq (char-after) ?\"))))
+ (goto-char placeholder)
+ (c-add-syntax 'extern-lang-open (c-point 'boi)))
+ ;; CASE 5A.2: we are looking at a class opening brace
+ ((save-excursion
+ (goto-char indent-point)
+ (skip-chars-forward " \t{")
+ ;; TBD: watch out! there could be a bogus
+ ;; c-state-cache in place when we get here. we have
+ ;; to go through much chicanery to ignore the cache.
+ ;; But of course, there may not be! BLECH! BOGUS!
+ (let ((decl
+ (if (boundp 'c-state-cache)
+ (let ((old-cache c-state-cache))
+ (prog2
+ (makunbound 'c-state-cache)
+ (c-search-uplist-for-classkey (c-parse-state))
+ (setq c-state-cache old-cache)))
+ (c-search-uplist-for-classkey (c-parse-state))
+ )))
+ (and decl
+ (setq placeholder (aref decl 0)))
+ ))
+ (c-add-syntax 'class-open placeholder))
+ ;; CASE 5A.3: brace list open
+ ((save-excursion
+ (c-beginning-of-statement-1 lim)
+ ;; c-b-o-s could have left us at point-min
+ (and (bobp)
+ (c-forward-syntactic-ws indent-point))
+ (if (looking-at "typedef[^_]")
+ (progn (forward-sexp 1)
+ (c-forward-syntactic-ws indent-point)))
+ (setq placeholder (c-point 'boi))
+ (and (or (looking-at "enum[ \t\n]+")
+ (eq char-before-ip ?=))
+ (save-excursion
+ (skip-chars-forward "^;(" indent-point)
+ (not (memq (char-after) '(?\; ?\()))
+ )))
+ (c-add-syntax 'brace-list-open placeholder))
+ ;; CASE 5A.4: inline defun open
+ ((and inclass-p (not inextern-p))
+ (c-add-syntax 'inline-open)
+ (c-add-syntax 'inclass (aref inclass-p 0)))
+ ;; CASE 5A.5: ordinary defun open
+ (t
+ (goto-char placeholder)
+ (c-add-syntax 'defun-open (c-point 'bol))
+ )))
+ ;; CASE 5B: first K&R arg decl or member init
+ ((c-just-after-func-arglist-p)
+ (cond
+ ;; CASE 5B.1: a member init
+ ((or (eq char-before-ip ?:)
+ (eq char-after-ip ?:))
+ ;; this line should be indented relative to the beginning
+ ;; of indentation for the topmost-intro line that contains
+ ;; the prototype's open paren
+ ;; TBD: is the following redundant?
+ (if (eq char-before-ip ?:)
+ (forward-char -1))
+ (c-backward-syntactic-ws lim)
+ ;; TBD: is the preceding redundant?
+ (if (eq (char-before) ?:)
+ (progn (forward-char -1)
+ (c-backward-syntactic-ws lim)))
+ (if (eq (char-before) ?\))
+ (backward-sexp 1))
+ (setq placeholder (point))
+ (save-excursion
+ (and (c-safe (backward-sexp 1) t)
+ (looking-at "throw[^_]")
+ (c-safe (backward-sexp 1) t)
+ (setq placeholder (point))))
+ (goto-char placeholder)
+ (c-add-syntax 'member-init-intro (c-point 'boi))
+ ;; we don't need to add any class offset since this
+ ;; should be relative to the ctor's indentation
+ )
+ ;; CASE 5B.2: K&R arg decl intro
+ (c-recognize-knr-p
+ (c-add-syntax 'knr-argdecl-intro (c-point 'boi))
+ (and inclass-p (c-add-syntax 'inclass (aref inclass-p 0))))
+ ;; CASE 5B.3: Nether region after a C++ or Java func
+ ;; decl, which could include a `throws' declaration.
+ (t
+ (c-beginning-of-statement-1 lim)
+ (c-add-syntax 'func-decl-cont (c-point 'boi))
+ )))
+ ;; CASE 5C: inheritance line. could be first inheritance
+ ;; line, or continuation of a multiple inheritance
+ ((or (and c-baseclass-key (looking-at c-baseclass-key))
+ (and (or (eq char-before-ip ?:)
+ ;; watch out for scope operator
+ (save-excursion
+ (and (eq char-after-ip ?:)
+ (c-safe (progn (forward-char 1) t))
+ (not (eq (char-after) ?:))
+ )))
+ (save-excursion
+ (c-backward-syntactic-ws lim)
+ (if (eq char-before-ip ?:)
+ (progn
+ (forward-char -1)
+ (c-backward-syntactic-ws lim)))
+ (back-to-indentation)
+ (looking-at c-class-key)))
+ ;; for Java
+ (and (eq major-mode 'java-mode)
+ (let ((fence (save-excursion
+ (c-beginning-of-statement-1 lim)
+ (point)))
+ cont done)
+ (save-excursion
+ (while (not done)
+ (cond ((looking-at c-Java-special-key)
+ (setq injava-inher (cons cont (point))
+ done t))
+ ((or (not (c-safe (forward-sexp -1) t))
+ (<= (point) fence))
+ (setq done t))
+ )
+ (setq cont t)))
+ injava-inher)
+ (not (c-crosses-statement-barrier-p (cdr injava-inher)
+ (point)))
+ ))
+ (cond
+ ;; CASE 5C.1: non-hanging colon on an inher intro
+ ((eq char-after-ip ?:)
+ (c-backward-syntactic-ws lim)
+ (c-add-syntax 'inher-intro (c-point 'boi))
+ ;; don't add inclass symbol since relative point already
+ ;; contains any class offset
+ )
+ ;; CASE 5C.2: hanging colon on an inher intro
+ ((eq char-before-ip ?:)
+ (c-add-syntax 'inher-intro (c-point 'boi))
+ (and inclass-p (c-add-syntax 'inclass (aref inclass-p 0))))
+ ;; CASE 5C.3: in a Java implements/extends
+ (injava-inher
+ (let ((where (cdr injava-inher))
+ (cont (car injava-inher)))
+ (goto-char where)
+ (cond ((looking-at "throws[ \t\n]")
+ (c-add-syntax 'func-decl-cont
+ (progn (c-beginning-of-statement-1 lim)
+ (c-point 'boi))))
+ (cont (c-add-syntax 'inher-cont where))
+ (t (c-add-syntax 'inher-intro
+ (progn (goto-char (cdr injava-inher))
+ (c-beginning-of-statement-1 lim)
+ (point))))
+ )))
+ ;; CASE 5C.4: a continued inheritance line
+ (t
+ (c-beginning-of-inheritance-list lim)
+ (c-add-syntax 'inher-cont (point))
+ ;; don't add inclass symbol since relative point already
+ ;; contains any class offset
+ )))
+ ;; CASE 5D: this could be a top-level compound statement or a
+ ;; member init list continuation
+ ((eq char-before-ip ?,)
+ (goto-char indent-point)
+ (c-backward-syntactic-ws lim)
+ (while (and (< lim (point))
+ (eq (char-before) ?,))
+ ;; this will catch member inits with multiple
+ ;; line arglists
+ (forward-char -1)
+ (c-backward-syntactic-ws (c-point 'bol))
+ (if (eq (char-before) ?\))
+ (backward-sexp 1))
+ ;; now continue checking
+ (beginning-of-line)
+ (c-backward-syntactic-ws lim))
+ (cond
+ ;; CASE 5D.1: hanging member init colon, but watch out
+ ;; for bogus matches on access specifiers inside classes.
+ ((and (eq (char-before) ?:)
+ (save-excursion
+ (forward-word -1)
+ (not (looking-at c-access-key))))
+ (goto-char indent-point)
+ (c-backward-syntactic-ws lim)
+ (c-safe (backward-sexp 1))
+ (c-add-syntax 'member-init-cont (c-point 'boi))
+ ;; we do not need to add class offset since relative
+ ;; point is the member init above us
+ )
+ ;; CASE 5D.2: non-hanging member init colon
+ ((progn
+ (c-forward-syntactic-ws indent-point)
+ (eq (char-after) ?:))
+ (skip-chars-forward " \t:")
+ (c-add-syntax 'member-init-cont (point)))
+ ;; CASE 5D.3: perhaps a multiple inheritance line?
+ ((looking-at c-inher-key)
+ (c-add-syntax 'inher-cont (c-point 'boi)))
+ ;; CASE 5D.4: perhaps a template list continuation?
+ ((save-excursion
+ (skip-chars-backward "^<" lim)
+ ;; not sure if this is the right test, but it should
+ ;; be fast and mostly accurate.
+ (and (eq (char-before) ?<)
+ (not (c-in-literal lim))))
+ ;; we can probably indent it just like and arglist-cont
+ (c-add-syntax 'arglist-cont (point)))
+ ;; CASE 5D.5: perhaps a top-level statement-cont
+ (t
+ (c-beginning-of-statement-1 lim)
+ ;; skip over any access-specifiers
+ (and inclass-p c-access-key
+ (while (looking-at c-access-key)
+ (forward-line 1)))
+ ;; skip over comments, whitespace
+ (c-forward-syntactic-ws indent-point)
+ (c-add-syntax 'statement-cont (c-point 'boi)))
+ ))
+ ;; CASE 5E: we are looking at a access specifier
+ ((and inclass-p
+ c-access-key
+ (looking-at c-access-key))
+ (c-add-syntax 'access-label (c-point 'bonl))
+ (c-add-syntax 'inclass (aref inclass-p 0)))
+ ;; CASE 5F: extern-lang-close?
+ ((and inextern-p
+ (eq char-after-ip ?}))
+ (c-add-syntax 'extern-lang-close (aref inclass-p 1)))
+ ;; CASE 5G: we are looking at the brace which closes the
+ ;; enclosing nested class decl
+ ((and inclass-p
+ (eq char-after-ip ?})
+ (save-excursion
+ (save-restriction
+ (widen)
+ (forward-char 1)
+ (and
+ (condition-case nil
+ (progn (backward-sexp 1) t)
+ (error nil))
+ (= (point) (aref inclass-p 1))
+ ))))
+ (save-restriction
+ (widen)
+ (goto-char (aref inclass-p 0))
+ (c-add-syntax 'class-close (c-point 'boi))))
+ ;; CASE 5H: we could be looking at subsequent knr-argdecls
+ ((and c-recognize-knr-p
+ ;; here we essentially use the hack that is used in
+ ;; Emacs' c-mode.el to limit how far back we should
+ ;; look. The assumption is made that argdecls are
+ ;; indented at least one space and that function
+ ;; headers are not indented.
+ (let ((limit (save-excursion
+ (re-search-backward "^[^ \^L\t\n#]" nil 'move)
+ (point))))
+ (save-excursion
+ (c-backward-syntactic-ws limit)
+ (setq placeholder (point))
+ (while (and (memq (char-before) '(?\; ?,))
+ (> (point) limit))
+ (beginning-of-line)
+ (setq placeholder (point))
+ (c-backward-syntactic-ws limit))
+ (and (eq (char-before) ?\))
+ (or (not c-method-key)
+ (progn
+ (forward-sexp -1)
+ (forward-char -1)
+ (c-backward-syntactic-ws)
+ (not (or (memq (char-before) '(?- ?+))
+ ;; or a class category
+ (progn
+ (forward-sexp -2)
+ (looking-at c-class-key))
+ )))))
+ ))
+ (save-excursion
+ (c-beginning-of-statement-1)
+ (not (looking-at "typedef[ \t\n]+"))))
+ (goto-char placeholder)
+ (c-add-syntax 'knr-argdecl (c-point 'boi)))
+ ;; CASE 5I: we are at the topmost level, make sure we skip
+ ;; back past any access specifiers
+ ((progn
+ (c-backward-syntactic-ws lim)
+ (while (and inclass-p
+ c-access-key
+ (not (bobp))
+ (save-excursion
+ (c-safe (progn (backward-sexp 1) t))
+ (looking-at c-access-key)))
+ (backward-sexp 1)
+ (c-backward-syntactic-ws lim))
+ (or (bobp)
+ (memq (char-before) '(?\; ?\}))))
+ ;; real beginning-of-line could be narrowed out due to
+ ;; enclosure in a class block
+ (save-restriction
+ (widen)
+ (c-add-syntax 'topmost-intro (c-point 'bol))
+ (if inclass-p
+ (progn
+ (goto-char (aref inclass-p 1))
+ (if inextern-p
+ (c-add-syntax 'inextern-lang)
+ (c-add-syntax 'inclass (c-point 'boi)))))
+ ))
+ ;; CASE 5J: we are at an ObjC or Java method definition
+ ;; continuation line.
+ ((and c-method-key
+ (progn
+ (c-beginning-of-statement-1 lim)
+ (beginning-of-line)
+ (looking-at c-method-key)))
+ (c-add-syntax 'objc-method-args-cont (point)))
+ ;; CASE 5K: we are at a topmost continuation line
+ (t
+ (c-beginning-of-statement-1 lim)
+ (c-forward-syntactic-ws)
+ (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
+ )) ; end CASE 5
+ ;; CASE 6: line is an expression, not a statement. Most
+ ;; likely we are either in a function prototype or a function
+ ;; call argument list
+ ((not (eq (char-after containing-sexp) ?{))
+ (c-backward-syntactic-ws containing-sexp)
+ (cond
+ ;; CASE 6A: we are looking at the arglist closing paren
+ ((and (not (eq char-before-ip ?,))
+ (memq char-after-ip '(?\) ?\])))
+ (goto-char containing-sexp)
+ (c-add-syntax 'arglist-close (c-point 'boi)))
+ ;; CASE 6B: we are looking at the first argument in an empty
+ ;; argument list. Use arglist-close if we're actually
+ ;; looking at a close paren or bracket.
+ ((memq char-before-ip '(?\( ?\[))
+ (goto-char containing-sexp)
+ (c-add-syntax 'arglist-intro (c-point 'boi)))
+ ;; CASE 6C: we are inside a conditional test clause. treat
+ ;; these things as statements
+ ((save-excursion
+ (goto-char containing-sexp)
+ (and (c-safe (progn (forward-sexp -1) t))
+ (looking-at "\\<for\\>[^_]")))
+ (goto-char (1+ containing-sexp))
+ (c-forward-syntactic-ws indent-point)
+ (c-beginning-of-statement-1 containing-sexp)
+ (if (eq char-before-ip ?\;)
+ (c-add-syntax 'statement (point))
+ (c-add-syntax 'statement-cont (point))
+ ))
+ ;; CASE 6D: maybe a continued method call. This is the case
+ ;; when we are inside a [] bracketed exp, and what precede
+ ;; the opening bracket is not an identifier.
+ ((and c-method-key
+ (eq (char-after containing-sexp) ?\[)
+ (save-excursion
+ (goto-char (1- containing-sexp))
+ (c-backward-syntactic-ws (c-point 'bod))
+ (if (not (looking-at c-symbol-key))
+ (c-add-syntax 'objc-method-call-cont containing-sexp))
+ )))
+ ;; CASE 6E: we are looking at an arglist continuation line,
+ ;; but the preceding argument is on the same line as the
+ ;; opening paren. This case includes multi-line
+ ;; mathematical paren groupings, but we could be on a
+ ;; for-list continuation line
+ ((and (save-excursion
+ (goto-char (1+ containing-sexp))
+ (skip-chars-forward " \t")
+ (not (eolp)))
+ (save-excursion
+ (c-beginning-of-statement-1 lim)
+ (skip-chars-backward " \t([")
+ (<= (point) containing-sexp)))
+ (goto-char containing-sexp)
+ (c-add-syntax 'arglist-cont-nonempty (c-point 'boi)))
+ ;; CASE 6F: we are looking at just a normal arglist
+ ;; continuation line
+ (t (c-beginning-of-statement-1 containing-sexp)
+ (forward-char 1)
+ (c-forward-syntactic-ws indent-point)
+ (c-add-syntax 'arglist-cont (c-point 'boi)))
+ ))
+ ;; CASE 7: func-local multi-inheritance line
+ ((and c-baseclass-key
+ (save-excursion
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ (looking-at c-baseclass-key)))
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ (cond
+ ;; CASE 7A: non-hanging colon on an inher intro
+ ((eq char-after-ip ?:)
+ (c-backward-syntactic-ws lim)
+ (c-add-syntax 'inher-intro (c-point 'boi)))
+ ;; CASE 7B: hanging colon on an inher intro
+ ((eq char-before-ip ?:)
+ (c-add-syntax 'inher-intro (c-point 'boi)))
+ ;; CASE 7C: a continued inheritance line
+ (t
+ (c-beginning-of-inheritance-list lim)
+ (c-add-syntax 'inher-cont (point))
+ )))
+ ;; CASE 8: we are inside a brace-list
+ ((setq placeholder (c-inside-bracelist-p containing-sexp state))
+ (cond
+ ;; CASE 8A: brace-list-close brace
+ ((and (eq char-after-ip ?})
+ (c-safe (progn (forward-char 1)
+ (backward-sexp 1)
+ t))
+ (= (point) containing-sexp))
+ (c-add-syntax 'brace-list-close (c-point 'boi)))
+ ;; CASE 8B: we're looking at the first line in a brace-list
+ ((save-excursion
+ (goto-char indent-point)
+ (c-backward-syntactic-ws containing-sexp)
+ (= (point) (1+ containing-sexp)))
+ (goto-char containing-sexp)
+ (c-add-syntax 'brace-list-intro (c-point 'boi))
+ )
+ ;;)) ; end CASE 8B
+ ;; CASE 8C: this is just a later brace-list-entry
+ (t (goto-char (1+ containing-sexp))
+ (c-forward-syntactic-ws indent-point)
+ (if (eq char-after-ip ?{)
+ (c-add-syntax 'brace-list-open (point))
+ (c-add-syntax 'brace-list-entry (point))
+ )) ; end CASE 8C
+ )) ; end CASE 8
+ ;; CASE 9: A continued statement
+ ((and (not (memq char-before-ip '(?\; ?} ?:)))
+ (> (point)
+ (save-excursion
+ (c-beginning-of-statement-1 containing-sexp)
+ (setq placeholder (point))))
+ (/= placeholder containing-sexp))
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ (let ((after-cond-placeholder
+ (save-excursion
+ (goto-char placeholder)
+ (if (looking-at c-conditional-key)
+ (progn
+ (c-safe (c-skip-conditional))
+ (c-forward-syntactic-ws)
+ (if (eq (char-after) ?\;)
+ (progn
+ (forward-char 1)
+ (c-forward-syntactic-ws)))
+ (point))
+ nil))))
+ (cond
+ ;; CASE 9A: substatement
+ ((and after-cond-placeholder
+ (>= after-cond-placeholder indent-point))
+ (goto-char placeholder)
+ (if (eq char-after-ip ?{)
+ (c-add-syntax 'substatement-open (c-point 'boi))
+ (c-add-syntax 'substatement (c-point 'boi))))
+ ;; CASE 9B: open braces for class or brace-lists
+ ((eq char-after-ip ?{)
+ (cond
+ ;; CASE 9B.1: class-open
+ ((save-excursion
+ (goto-char indent-point)
+ (skip-chars-forward " \t{")
+ (let ((decl (c-search-uplist-for-classkey (c-parse-state))))
+ (and decl
+ (setq placeholder (aref decl 0)))
+ ))
+ (c-add-syntax 'class-open placeholder))
+ ;; CASE 9B.2: brace-list-open
+ ((or (save-excursion
+ (goto-char placeholder)
+ (looking-at "\\<enum\\>"))
+ (eq char-before-ip ?=))
+ (c-add-syntax 'brace-list-open placeholder))
+ ;; CASE 9B.3: catch-all for unknown construct.
+ (t
+ ;; Can and should I add an extensibility hook here?
+ ;; Something like c-recognize-hook so support for
+ ;; unknown constructs could be added. It's probably a
+ ;; losing proposition, so I dunno.
+ (goto-char placeholder)
+ (c-add-syntax 'statement-cont (c-point 'boi))
+ (c-add-syntax 'block-open))
+ ))
+ ;; CASE 9C: iostream insertion or extraction operator
+ ((looking-at "<<\\|>>")
+ (goto-char placeholder)
+ (and after-cond-placeholder
+ (goto-char after-cond-placeholder))
+ (while (and (re-search-forward "<<\\|>>" indent-point 'move)
+ (c-in-literal placeholder)))
+ ;; if we ended up at indent-point, then the first
+ ;; streamop is on a separate line. Indent the line like
+ ;; a statement-cont instead
+ (if (/= (point) indent-point)
+ (c-add-syntax 'stream-op (c-point 'boi))
+ (c-backward-syntactic-ws lim)
+ (c-add-syntax 'statement-cont (c-point 'boi))))
+ ;; CASE 9D: continued statement. find the accurate
+ ;; beginning of statement or substatement
+ (t
+ (c-beginning-of-statement-1 after-cond-placeholder)
+ ;; KLUDGE ALERT! c-beginning-of-statement-1 can leave
+ ;; us before the lim we're passing in. It should be
+ ;; fixed, but I'm worried about side-effects at this
+ ;; late date. Fix for v5.
+ (goto-char (or (and after-cond-placeholder
+ (max after-cond-placeholder (point)))
+ (point)))
+ (c-add-syntax 'statement-cont (point)))
+ )))
+ ;; CASE 10: an else clause?
+ ((looking-at "\\<else\\>[^_]")
+ (c-backward-to-start-of-if containing-sexp)
+ (c-add-syntax 'else-clause (c-point 'boi)))
+ ;; CASE 11: Statement. But what kind? Lets see if its a
+ ;; while closure of a do/while construct
+ ((progn
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ (and (looking-at "while\\b[^_]")
+ (save-excursion
+ (c-backward-to-start-of-do containing-sexp)
+ (setq placeholder (point))
+ (looking-at "do\\b[^_]"))
+ ))
+ (c-add-syntax 'do-while-closure placeholder))
+ ;; CASE 12: A case or default label
+ ((looking-at c-switch-label-key)
+ (goto-char containing-sexp)
+ ;; check for hanging braces
+ (if (/= (point) (c-point 'boi))
+ (forward-sexp -1))
+ (c-add-syntax 'case-label (c-point 'boi)))
+ ;; CASE 13: any other label
+ ((looking-at c-label-key)
+ (goto-char containing-sexp)
+ (c-add-syntax 'label (c-point 'boi)))
+ ;; CASE 14: block close brace, possibly closing the defun or
+ ;; the class
+ ((eq char-after-ip ?})
+ (let* ((lim (c-safe-position containing-sexp fullstate))
+ (relpos (save-excursion
+ (goto-char containing-sexp)
+ (if (/= (point) (c-point 'boi))
+ (c-beginning-of-statement-1 lim))
+ (c-point 'boi))))
+ (cond
+ ;; CASE 14A: does this close an inline?
+ ((let ((inclass-p (progn
+ (goto-char containing-sexp)
+ (c-search-uplist-for-classkey state))))
+ ;; inextern-p in higher level let*
+ (setq inextern-p (and inclass-p
+ (progn
+ (goto-char (aref inclass-p 0))
+ (looking-at "extern[^_]"))))
+ (and inclass-p (not inextern-p)))
+ (c-add-syntax 'inline-close relpos))
+ ;; CASE 14B: if there an enclosing brace that hasn't
+ ;; been narrowed out by a class, then this is a
+ ;; block-close
+ ((and (not inextern-p)
+ (c-most-enclosing-brace state))
+ (c-add-syntax 'block-close relpos))
+ ;; CASE 14C: find out whether we're closing a top-level
+ ;; class or a defun
+ (t
+ (save-restriction
+ (narrow-to-region (point-min) indent-point)
+ (let ((decl (c-search-uplist-for-classkey (c-parse-state))))
+ (if decl
+ (c-add-syntax 'class-close (aref decl 0))
+ (c-add-syntax 'defun-close relpos)))))
+ )))
+ ;; CASE 15: statement catchall
+ (t
+ ;; we know its a statement, but we need to find out if it is
+ ;; the first statement in a block
+ (goto-char containing-sexp)
+ (forward-char 1)
+ (c-forward-syntactic-ws indent-point)
+ ;; now skip forward past any case/default clauses we might find.
+ (while (or (c-skip-case-statement-forward fullstate indent-point)
+ (and (looking-at c-switch-label-key)
+ (not inswitch-p)))
+ (setq inswitch-p t))
+ ;; we want to ignore non-case labels when skipping forward
+ (while (and (looking-at c-label-key)
+ (goto-char (match-end 0)))
+ (c-forward-syntactic-ws indent-point))
+ (cond
+ ;; CASE 15A: we are inside a case/default clause inside a
+ ;; switch statement. find out if we are at the statement
+ ;; just after the case/default label.
+ ((and inswitch-p
+ (progn
+ (goto-char indent-point)
+ (c-backward-syntactic-ws containing-sexp)
+ (back-to-indentation)
+ (setq placeholder (point))
+ (looking-at c-switch-label-key)))
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ (if (eq (char-after) ?{)
+ (c-add-syntax 'statement-case-open placeholder)
+ (c-add-syntax 'statement-case-intro placeholder)))
+ ;; CASE 15B: continued statement
+ ((eq char-before-ip ?,)
+ (c-add-syntax 'statement-cont (c-point 'boi)))
+ ;; CASE 15C: a question/colon construct? But make sure
+ ;; what came before was not a label, and what comes after
+ ;; is not a globally scoped function call!
+ ((or (and (memq char-before-ip '(?: ??))
+ (save-excursion
+ (goto-char indent-point)
+ (c-backward-syntactic-ws lim)
+ (back-to-indentation)
+ (not (looking-at c-label-key))))
+ (and (memq char-after-ip '(?: ??))
+ (save-excursion
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ ;; watch out for scope operator
+ (not (looking-at "::")))))
+ (c-add-syntax 'statement-cont (c-point 'boi)))
+ ;; CASE 15D: any old statement
+ ((< (point) indent-point)
+ (let ((safepos (c-most-enclosing-brace fullstate))
+ relpos done)
+ (goto-char indent-point)
+ (c-beginning-of-statement-1 safepos)
+ ;; It is possible we're on the brace that opens a nested
+ ;; function.
+ (if (and (eq (char-after) ?{)
+ (save-excursion
+ (c-backward-syntactic-ws safepos)
+ (not (eq (char-before) ?\;))))
+ (c-beginning-of-statement-1 safepos))
+ (if (and inswitch-p
+ (looking-at c-switch-label-key))
+ (progn
+ (goto-char placeholder)
+ (end-of-line)
+ (forward-sexp -1)))
+ (setq relpos (c-point 'boi))
+ (while (and (not done)
+ (<= safepos (point))
+ (/= relpos (point)))
+ (c-beginning-of-statement-1 safepos)
+ (if (= relpos (c-point 'boi))
+ (setq done t))
+ (setq relpos (c-point 'boi)))
+ (c-add-syntax 'statement relpos)
+ (if (eq char-after-ip ?{)
+ (c-add-syntax 'block-open))))
+ ;; CASE 15E: first statement in an inline, or first
+ ;; statement in a top-level defun. we can tell this is it
+ ;; if there are no enclosing braces that haven't been
+ ;; narrowed out by a class (i.e. don't use bod here!)
+ ((save-excursion
+ (save-restriction
+ (widen)
+ (goto-char containing-sexp)
+ (c-narrow-out-enclosing-class state containing-sexp)
+ (not (c-most-enclosing-brace state))))
+ (goto-char containing-sexp)
+ ;; if not at boi, then defun-opening braces are hung on
+ ;; right side, so we need a different relpos
+ (if (/= (point) (c-point 'boi))
+ (progn
+ (c-backward-syntactic-ws)
+ (c-safe (forward-sexp (if (eq (char-before) ?\))
+ -1 -2)))
+ ;; looking at a Java throws clause following a
+ ;; method's parameter list
+ (c-beginning-of-statement-1)
+ ))
+ (c-add-syntax 'defun-block-intro (c-point 'boi)))
+ ;; CASE 15F: first statement in a block
+ (t (goto-char containing-sexp)
+ (if (/= (point) (c-point 'boi))
+ (c-beginning-of-statement-1
+ (if (= (point) lim)
+ (c-safe-position (point) state) lim)))
+ (c-add-syntax 'statement-block-intro (c-point 'boi))
+ (if (eq char-after-ip ?{)
+ (c-add-syntax 'block-open)))
+ ))
+ )
+
+ ;; now we need to look at any modifiers
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ ;; are we looking at a comment only line?
+ (if (looking-at c-comment-start-regexp)
+ (c-add-syntax 'comment-intro))
+ ;; we might want to give additional offset to friends (in C++).
+ (if (and (eq major-mode 'c++-mode)
+ (looking-at c-C++-friend-key))
+ (c-add-syntax 'friend))
+ ;; return the syntax
+ syntax))))
+
+\f
+(defun c-echo-parsing-error ()
+ (if (not c-parsing-error)
+ nil
+ (message "unbalanced close brace at bufpos %d -- INDENTATION IS SUSPECT!"
+ c-parsing-error)
+ (ding))
+ c-parsing-error)
+
+;; indent via syntactic language elements
+(defun c-indent-line (&optional syntax)
+ ;; indent the current line as C/C++/ObjC code. Optional SYNTAX is the
+ ;; syntactic information for the current line. Returns the amount of
+ ;; indentation change
+ (let* ((c-syntactic-context (or syntax (c-guess-basic-syntax)))
+ (pos (- (point-max) (point)))
+ (indent (apply '+ (mapcar 'c-get-offset c-syntactic-context)))
+ (shift-amt (- (current-indentation) indent)))
+ (and c-echo-syntactic-information-p
+ (not (c-echo-parsing-error))
+ (message "syntax: %s, indent= %d" c-syntactic-context indent))
+ (if (zerop shift-amt)
+ nil
+ (delete-region (c-point 'bol) (c-point 'boi))
+ (beginning-of-line)
+ (indent-to indent))
+ (if (< (point) (c-point 'boi))
+ (back-to-indentation)
+ ;; If initial point was within line's indentation, position after
+ ;; the indentation. Else stay at same point in text.
+ (if (> (- (point-max) pos) (point))
+ (goto-char (- (point-max) pos)))
+ )
+ (run-hooks 'c-special-indent-hook)
+ shift-amt))
+
+(defun c-show-syntactic-information (arg)
+ "Show syntactic information for current line.
+With universal argument, inserts the analysis as a comment on that line."
+ (interactive "P")
+ (let ((syntax (c-guess-basic-syntax)))
+ (if (not (consp arg))
+ (if (not (c-echo-parsing-error))
+ (message "syntactic analysis: %s" syntax))
+ (indent-for-comment)
+ (insert (format "%s" syntax))
+ ))
+ (c-keep-region-active))
+
+\f
+(provide 'cc-engine)
+;;; cc-engine.el ends here
--- /dev/null
+;;; cc-langs.el --- specific language support for CC Mode
+
+;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
+
+;; Authors: 1992-1997 Barry A. Warsaw
+;; 1987 Dave Detlefs and Stewart Clamen
+;; 1985 Richard M. Stallman
+;; Maintainer: cc-mode-help@python.org
+;; Created: 22-Apr-1997 (split from cc-mode.el)
+;; Version: 5.12
+;; 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.
+
+\f
+;; Regular expressions and other values which must be parameterized on
+;; a per-language basis.
+
+;; Keywords defining protection levels
+(defconst c-protection-key "\\<\\(public\\|protected\\|private\\)\\>")
+
+;; Regex describing a `symbol' in all languages We cannot use just
+;; `word' syntax class since `_' cannot be in word class. Putting
+;; underscore in word class breaks forward word movement behavior that
+;; users are familiar with.
+(defconst c-symbol-key "\\(\\w\\|\\s_\\)+")
+
+\f
+;; keywords introducing class definitions. language specific
+(defconst c-C-class-key "\\(struct\\|union\\)")
+(defconst c-C++-class-key "\\(class\\|struct\\|union\\)")
+
+(defconst c-ObjC-class-key
+ (concat
+ "@\\(interface\\|implementation\\)\\s +"
+ c-symbol-key ;name of the class
+ "\\(\\s *:\\s *" c-symbol-key "\\)?" ;maybe followed by the superclass
+ "\\(\\s *<[^>]+>\\)?" ;and maybe the adopted protocols list
+ ))
+
+(defconst c-Java-class-key
+ (concat
+ "\\(" c-protection-key "\\s +\\)?"
+ "\\(interface\\|class\\)\\s +"
+ c-symbol-key ;name of the class
+ "\\(\\s *extends\\s *" c-symbol-key "\\)?" ;maybe followed by superclass
+ ;;"\\(\\s *implements *[^{]+{\\)?" ;maybe the adopted protocols list
+ ))
+
+(defvar c-class-key c-C-class-key)
+(make-variable-buffer-local 'c-class-key)
+
+\f
+;; regexp describing access protection clauses. language specific
+(defvar c-access-key nil)
+(make-variable-buffer-local 'c-access-key)
+(defconst c-C++-access-key (concat c-protection-key "[ \t]*:"))
+(defconst c-ObjC-access-key (concat "@" c-protection-key))
+(defconst c-Java-access-key nil)
+
+\f
+;; keywords introducing conditional blocks
+(defconst c-C-conditional-key nil)
+(defconst c-C++-conditional-key nil)
+(defconst c-Java-conditional-key nil)
+
+(let ((all-kws "for\\|if\\|do\\|else\\|while\\|switch")
+ (exc-kws "\\|try\\|catch")
+ (thr-kws "\\|finally\\|synchronized")
+ (front "\\b\\(")
+ (back "\\)\\b[^_]"))
+ (setq c-C-conditional-key (concat front all-kws back)
+ c-C++-conditional-key (concat front all-kws exc-kws back)
+ c-Java-conditional-key (concat front all-kws exc-kws thr-kws back)))
+
+(defvar c-conditional-key c-C-conditional-key)
+(make-variable-buffer-local 'c-conditional-key)
+
+\f
+;; keywords describing method definition introductions
+(defvar c-method-key nil)
+(make-variable-buffer-local 'c-method-key)
+
+(defconst c-ObjC-method-key
+ (concat
+ "^\\s *[+-]\\s *"
+ "\\(([^)]*)\\)?" ; return type
+ ;; \\s- in objc syntax table does not include \n
+ ;; since it is considered the end of //-comments.
+ "[ \t\n]*" c-symbol-key))
+
+(defconst c-Java-method-key
+ (concat
+ "^\\s *[+-]\\s *"
+ "\\(([^)]*)\\)?" ; return type
+ ;; \\s- in java syntax table does not include \n
+ ;; since it is considered the end of //-comments.
+ "[ \t\n]*" c-symbol-key))
+
+\f
+;; comment starter definitions for various languages. language specific
+(defconst c-C-comment-start-regexp "/[*]")
+(defconst c-C++-comment-start-regexp "/[/*]")
+;; We need to match all 3 Java style comments
+;; 1) Traditional C block; 2) javadoc /** ...; 3) C++ style
+(defconst c-Java-comment-start-regexp "/\\(/\\|[*][*]?\\)")
+(defvar c-comment-start-regexp c-C-comment-start-regexp)
+(make-variable-buffer-local 'c-comment-start-regexp)
+
+
+\f
+;; Regexp describing a switch's case or default label for all languages
+(defconst c-switch-label-key "\\(\\(case[( \t]+\\S .*\\)\\|default[ \t]*\\):")
+;; Regexp describing any label.
+(defconst c-label-key (concat c-symbol-key ":\\([^:]\\|$\\)"))
+
+;; Regexp describing class inheritance declarations. TBD: this should
+;; be language specific, and only makes sense for C++
+(defconst c-inher-key
+ (concat "\\(\\<static\\>\\s +\\)?"
+ c-C++-class-key "[ \t]+" c-symbol-key
+ "\\([ \t]*:[ \t]*\\)\\s *[^;]"))
+
+;; Regexp describing C++ base classes in a derived class definition.
+;; TBD: this should be language specific, and only makes sense for C++
+(defvar c-baseclass-key
+ (concat
+ ":?[ \t]*\\(virtual[ \t]+\\)?\\("
+ c-protection-key "[ \t]+\\)" c-symbol-key))
+(make-variable-buffer-local 'c-baseclass-key)
+
+;; Regexp describing friend declarations in C++ classes.
+(defconst c-C++-friend-key
+ "friend[ \t]+\\|template[ \t]*<.+>[ \t]*friend[ \t]+")
+
+;; Regexp describing Java inheritance and throws clauses.
+(defconst c-Java-special-key "\\(implements\\|extends\\|throws\\)[^_]")
+
+;; Regexp describing the beginning of a Java top-level definition.
+(defconst c-Java-defun-prompt-regexp
+ "^[ \t]*\\(\\(\\(public\\|protected\\|private\\|const\\|abstract\\|synchronized\\|final\\|static\\|threadsafe\\|transient\\|native\\|volatile\\)\\s-+\\)*\\(\\(\\([[a-zA-Z][][_$.a-zA-Z0-9]*[][_$.a-zA-Z0-9]+\\|[[a-zA-Z]\\)\\s-*\\)\\s-+\\)\\)?\\(\\([[a-zA-Z][][_$.a-zA-Z0-9]*\\s-+\\)\\s-*\\)?\\([_a-zA-Z][^][ \t:;.,{}()\7f=]*\\|\\([_$a-zA-Z][_$.a-zA-Z0-9]*\\)\\)\\s-*\\(([^);{}]*)\\)?\\([] \t]*\\)\\(\\s-*\\<throws\\>\\s-*\\(\\([_$a-zA-Z][_$.a-zA-Z0-9]*\\)[, \t\n\r\f]*\\)+\\)?\\s-*")
+
+
+\f
+;; internal state variables
+
+;; Internal state of hungry delete key feature
+(defvar c-hungry-delete-key nil)
+(make-variable-buffer-local 'c-hungry-delete-key)
+
+;; Internal state of auto newline feature.
+(defvar c-auto-newline nil)
+(make-variable-buffer-local 'c-auto-newline)
+
+;; Internal auto-newline/hungry-delete designation string for mode line.
+(defvar c-auto-hungry-string nil)
+(make-variable-buffer-local 'c-auto-hungry-string)
+
+;; Buffer local language-specific comment style flag.
+(defvar c-double-slash-is-comments-p nil)
+(make-variable-buffer-local 'c-double-slash-is-comments-p)
+
+;; Non-nil means K&R style argument declarations are valid.
+(defvar c-recognize-knr-p t)
+(make-variable-buffer-local 'c-recognize-knr-p)
+
+
+\f
+(defun c-use-java-style ()
+ "Institutes `java' indentation style.
+For use with the variable `java-mode-hook'."
+ (c-set-style "java"))
+
+(defvar c-styles-are-initialized nil)
+
+(defun c-common-init ()
+ ;; Common initializations for all modes.
+ (if c-styles-are-initialized
+ nil
+ (require 'cc-styles)
+ (c-initialize-builtin-style)
+ (if c-style-variables-are-local-p
+ (c-make-styles-buffer-local))
+ (setq c-styles-are-initialized t))
+ ;; these variables should always be buffer local; they do not affect
+ ;; indentation style.
+ (make-local-variable 'paragraph-start)
+ (make-local-variable 'paragraph-separate)
+ (make-local-variable 'paragraph-ignore-fill-prefix)
+ (make-local-variable 'require-final-newline)
+ (make-local-variable 'parse-sexp-ignore-comments)
+ (make-local-variable 'indent-line-function)
+ (make-local-variable 'indent-region-function)
+ (make-local-variable 'comment-start)
+ (make-local-variable 'comment-end)
+ (make-local-variable 'comment-column)
+ (make-local-variable 'comment-start-skip)
+ (make-local-variable 'comment-multi-line)
+ (make-local-variable 'outline-regexp)
+ (make-local-variable 'outline-level)
+ (make-local-variable 'adaptive-fill-regexp)
+ (make-local-variable 'imenu-generic-expression) ;set in the mode functions
+ ;; Emacs 19.30 and beyond only, AFAIK
+ (if (boundp 'fill-paragraph-function)
+ (progn
+ (make-local-variable 'fill-paragraph-function)
+ (setq fill-paragraph-function 'c-fill-paragraph)))
+ ;; now set their values
+ (setq paragraph-start (concat page-delimiter "\\|$")
+ paragraph-separate paragraph-start
+ paragraph-ignore-fill-prefix t
+ require-final-newline t
+ parse-sexp-ignore-comments t
+ indent-line-function 'c-indent-line
+ indent-region-function 'c-indent-region
+ outline-regexp "[^#\n\^M]"
+ outline-level 'c-outline-level
+ comment-column 32
+ comment-start-skip "/\\*+ *\\|// *"
+ adaptive-fill-regexp nil)
+ ;; we have to do something special for c-offsets-alist so that the
+ ;; buffer local value has its own alist structure.
+ (setq c-offsets-alist (copy-alist c-offsets-alist))
+ ;; setup the comment indent variable in a Emacs version portable way
+ ;; ignore any byte compiler warnings you might get here
+ (make-local-variable 'comment-indent-function)
+ (setq comment-indent-function 'c-comment-indent)
+ ;; add menus to menubar
+ (easy-menu-add (c-mode-menu mode-name))
+ ;; put auto-hungry designators onto minor-mode-alist, but only once
+ (or (assq 'c-auto-hungry-string minor-mode-alist)
+ (setq minor-mode-alist
+ (cons '(c-auto-hungry-string c-auto-hungry-string)
+ minor-mode-alist))))
+
+(defun c-postprocess-file-styles ()
+ "Function that post processes relevant file local variables.
+Currently, this function simply applies any style and offset settings
+found in the file's Local Variable list. It first applies any style
+setting found in `c-file-style', then it applies any offset settings
+it finds in `c-file-offsets'."
+ ;; apply file styles and offsets
+ (and c-file-style
+ (c-set-style c-file-style))
+ (and c-file-offsets
+ (mapcar
+ (function
+ (lambda (langentry)
+ (let ((langelem (car langentry))
+ (offset (cdr langentry)))
+ (c-set-offset langelem offset)
+ )))
+ c-file-offsets)))
+
+(add-hook 'hack-local-variables-hook 'c-postprocess-file-styles)
+
+\f
+;; Common routines
+(defsubst c-make-inherited-keymap ()
+ (let ((map (make-sparse-keymap)))
+ (cond
+ ;; XEmacs 19 & 20
+ ((fboundp 'set-keymap-parents)
+ (set-keymap-parents map c-mode-base-map))
+ ;; Emacs 19
+ ((fboundp 'set-keymap-parent)
+ (set-keymap-parent map c-mode-base-map))
+ ;; incompatible
+ (t (error "CC Mode is incompatible with this version of Emacs")))
+ map))
+
+(defun c-populate-syntax-table (table)
+ ;; Populate the syntax TABLE
+ ;; DO NOT TRY TO SET _ (UNDERSCORE) TO WORD CLASS!
+ (modify-syntax-entry ?_ "_" table)
+ (modify-syntax-entry ?\\ "\\" table)
+ (modify-syntax-entry ?+ "." table)
+ (modify-syntax-entry ?- "." table)
+ (modify-syntax-entry ?= "." table)
+ (modify-syntax-entry ?% "." table)
+ (modify-syntax-entry ?< "." table)
+ (modify-syntax-entry ?> "." table)
+ (modify-syntax-entry ?& "." table)
+ (modify-syntax-entry ?| "." table)
+ (modify-syntax-entry ?\' "\"" table))
+
+(defun c-setup-dual-comments (table)
+ ;; Set up TABLE to handle block and line style comments
+ (cond
+ ;; XEmacs 19 & 20
+ ((memq '8-bit c-emacs-features)
+ (modify-syntax-entry ?/ ". 1456" table)
+ (modify-syntax-entry ?* ". 23" table)
+ (modify-syntax-entry ?\n "> b" table)
+ ;; Give CR the same syntax as newline, for selective-display
+ (modify-syntax-entry ?\^m "> b" table))
+ ;; Emacs 19
+ ((memq '1-bit c-emacs-features)
+ (modify-syntax-entry ?/ ". 124b" table)
+ (modify-syntax-entry ?* ". 23" table)
+ (modify-syntax-entry ?\n "> b" table)
+ ;; Give CR the same syntax as newline, for selective-display
+ (modify-syntax-entry ?\^m "> b" table))
+ ;; incompatible
+ (t (error "CC Mode is incompatible with this version of Emacs"))
+ ))
+
+(defvar c-mode-base-map ()
+ "Keymap shared by all CC Mode related modes.")
+
+(if c-mode-base-map
+ nil
+ ;; TBD: should we even worry about naming this keymap. My vote: no,
+ ;; because Emacs and XEmacs do it differently.
+ (setq c-mode-base-map (make-sparse-keymap))
+ ;; put standard keybindings into MAP
+ ;; the following mappings correspond more or less directly to BOCM
+ (define-key c-mode-base-map "{" 'c-electric-brace)
+ (define-key c-mode-base-map "}" 'c-electric-brace)
+ (define-key c-mode-base-map ";" 'c-electric-semi&comma)
+ (define-key c-mode-base-map "#" 'c-electric-pound)
+ (define-key c-mode-base-map ":" 'c-electric-colon)
+ ;; Lucid Emacs 19.9 defined these two, the second of which was
+ ;; commented out...
+ ;; (define-key c-mode-base-map "\e{" 'c-insert-braces)
+ ;; Commented out electric square brackets because nobody likes them.
+ ;; (define-key c-mode-base-map "[" 'c-insert-brackets)
+ (define-key c-mode-base-map "\C-c\C-m" 'c-mark-function)
+ (define-key c-mode-base-map "\e\C-q" 'c-indent-exp)
+ (define-key c-mode-base-map "\ea" 'c-beginning-of-statement)
+ (define-key c-mode-base-map "\ee" 'c-end-of-statement)
+ (define-key c-mode-base-map "\C-c\C-n" 'c-forward-conditional)
+ (define-key c-mode-base-map "\C-c\C-p" 'c-backward-conditional)
+ (define-key c-mode-base-map "\C-c\C-u" 'c-up-conditional)
+ (define-key c-mode-base-map "\t" 'c-indent-command)
+ ;; Caution! Enter here at your own risk. We are trying to support
+ ;; several behaviors and it gets disgusting. :-(
+ ;;
+ ;; In XEmacs 19, Emacs 19, and Emacs 20, we use this to bind
+ ;; backwards deletion behavior to DEL, which both Delete and
+ ;; Backspace get translated to. There's no way to separate this
+ ;; behavior in a clean way, so deal with it! Besides, it's been
+ ;; this way since the dawn of BOCM.
+ (if (not (boundp 'delete-key-deletes-forward))
+ (define-key c-mode-base-map "\177" 'c-electric-backspace)
+ ;; However, XEmacs 20 actually achieved enlightenment. It is
+ ;; possible to sanely define both backward and forward deletion
+ ;; behavior under X separately (TTYs are forever beyond hope, but
+ ;; who cares? XEmacs 20 does the right thing with these too).
+ (define-key c-mode-base-map [delete] 'c-electric-delete)
+ (define-key c-mode-base-map [backspace] 'c-electric-backspace))
+ ;; these are new keybindings, with no counterpart to BOCM
+ (define-key c-mode-base-map "," 'c-electric-semi&comma)
+ (define-key c-mode-base-map "*" 'c-electric-star)
+ (define-key c-mode-base-map "\C-c\C-q" 'c-indent-defun)
+ (define-key c-mode-base-map "\C-c\C-\\" 'c-backslash-region)
+ ;; TBD: where if anywhere, to put c-backward|forward-into-nomenclature
+ (define-key c-mode-base-map "\C-c\C-a" 'c-toggle-auto-state)
+ (define-key c-mode-base-map "\C-c\C-b" 'c-submit-bug-report)
+ (define-key c-mode-base-map "\C-c\C-c" 'comment-region)
+ (define-key c-mode-base-map "\C-c\C-d" 'c-toggle-hungry-state)
+ (define-key c-mode-base-map "\C-c\C-e" 'c-macro-expand)
+ (define-key c-mode-base-map "\C-c\C-o" 'c-set-offset)
+ (define-key c-mode-base-map "\C-c\C-s" 'c-show-syntactic-information)
+ (define-key c-mode-base-map "\C-c\C-t" 'c-toggle-auto-hungry-state)
+ (define-key c-mode-base-map "\C-c." 'c-set-style)
+ ;; conflicts with OOBR
+ ;;(define-key c-mode-base-map "\C-c\C-v" 'c-version)
+ )
+
+;; menu support for both XEmacs and Emacs. If you don't have easymenu
+;; with your version of Emacs, you are incompatible!
+(require 'easymenu)
+
+(defvar c-c-menu nil)
+(defvar c-c++-menu nil)
+(defvar c-objc-menu nil)
+(defvar c-java-menu nil)
+
+(defun c-mode-menu (modestr)
+ (let ((m
+ '(["Comment Out Region" comment-region (mark)]
+ ["Macro Expand Region" c-macro-expand (mark)]
+ ["Backslashify" c-backslash-region (mark)]
+ ["Indent Expression" c-indent-exp
+ (memq (char-after) '(?\( ?\[ ?\{))]
+ ["Indent Line" c-indent-command t]
+ ["Fill Comment Paragraph" c-fill-paragraph t]
+ ["Up Conditional" c-up-conditional t]
+ ["Backward Conditional" c-backward-conditional t]
+ ["Forward Conditional" c-forward-conditional t]
+ ["Backward Statement" c-beginning-of-statement t]
+ ["Forward Statement" c-end-of-statement t]
+ )))
+ (cons modestr m)))
+
+
+\f
+;; Support for C
+
+(defvar c-mode-abbrev-table nil
+ "Abbrev table in use in c-mode buffers.")
+(define-abbrev-table 'c-mode-abbrev-table ())
+
+(defvar c-mode-map ()
+ "Keymap used in c-mode buffers.")
+(if c-mode-map
+ nil
+ (setq c-mode-map (c-make-inherited-keymap))
+ ;; add bindings which are only useful for C
+ )
+
+;;;###autoload
+(defvar c-mode-syntax-table nil
+ "Syntax table used in c-mode buffers.")
+(if c-mode-syntax-table
+ ()
+ (setq c-mode-syntax-table (make-syntax-table))
+ (c-populate-syntax-table c-mode-syntax-table)
+ ;; add extra comment syntax
+ (modify-syntax-entry ?/ ". 14" c-mode-syntax-table)
+ (modify-syntax-entry ?* ". 23" c-mode-syntax-table))
+
+(defun c-enable-//-in-c-mode ()
+ "Enables // as a comment delimiter in `c-mode'.
+ANSI C currently does *not* allow this, although many C compilers
+support optional C++ style comments. To use, call this function from
+your `.emacs' file before you visit any C files. The changes are
+global and affect all future `c-mode' buffers."
+ (c-setup-dual-comments c-mode-syntax-table)
+ (setq-default c-C-comment-start-regexp c-C++-comment-start-regexp))
+
+(easy-menu-define c-c-menu c-mode-map "C Mode Commands"
+ (c-mode-menu "C"))
+
+\f
+;; Support for C++
+
+(defvar c++-mode-abbrev-table nil
+ "Abbrev table in use in c++-mode buffers.")
+(define-abbrev-table 'c++-mode-abbrev-table ())
+
+(defvar c++-mode-map ()
+ "Keymap used in c++-mode buffers.")
+(if c++-mode-map
+ nil
+ (setq c++-mode-map (c-make-inherited-keymap))
+ ;; add bindings which are only useful for C++
+ (define-key c++-mode-map "\C-c:" 'c-scope-operator)
+ (define-key c++-mode-map "/" 'c-electric-slash)
+ (define-key c++-mode-map "<" 'c-electric-lt-gt)
+ (define-key c++-mode-map ">" 'c-electric-lt-gt))
+
+(defvar c++-mode-syntax-table nil
+ "Syntax table used in c++-mode buffers.")
+(if c++-mode-syntax-table
+ ()
+ (setq c++-mode-syntax-table (make-syntax-table))
+ (c-populate-syntax-table c++-mode-syntax-table)
+ ;; add extra comment syntax
+ (c-setup-dual-comments c++-mode-syntax-table)
+ ;; TBD: does it make sense for colon to be symbol class in C++?
+ ;; I'm not so sure, since c-label-key is busted on lines like:
+ ;; Foo::bar( i );
+ ;; maybe c-label-key should be fixed instead of commenting this out,
+ ;; but it also bothers me that this only seems appropriate for C++
+ ;; and not C.
+ ;;(modify-syntax-entry ?: "_" c++-mode-syntax-table)
+ )
+
+(easy-menu-define c-c++-menu c++-mode-map "C++ Mode Commands"
+ (c-mode-menu "C++"))
+
+\f
+;; Support for Objective-C
+
+(defvar objc-mode-abbrev-table nil
+ "Abbrev table in use in objc-mode buffers.")
+(define-abbrev-table 'objc-mode-abbrev-table ())
+
+(defvar objc-mode-map ()
+ "Keymap used in objc-mode buffers.")
+(if objc-mode-map
+ nil
+ (setq objc-mode-map (c-make-inherited-keymap))
+ ;; add bindings which are only useful for Objective-C
+ (define-key objc-mode-map "/" 'c-electric-slash))
+
+(defvar objc-mode-syntax-table nil
+ "Syntax table used in objc-mode buffers.")
+(if objc-mode-syntax-table
+ ()
+ (setq objc-mode-syntax-table (make-syntax-table))
+ (c-populate-syntax-table objc-mode-syntax-table)
+ ;; add extra comment syntax
+ (c-setup-dual-comments objc-mode-syntax-table)
+ ;; everyone gets these
+ (modify-syntax-entry ?@ "_" objc-mode-syntax-table)
+ )
+
+(easy-menu-define c-objc-menu objc-mode-map "ObjC Mode Commands"
+ (c-mode-menu "ObjC"))
+
+\f
+;; Support for Java
+
+(defvar java-mode-abbrev-table nil
+ "Abbrev table in use in java-mode buffers.")
+(define-abbrev-table 'java-mode-abbrev-table ())
+
+(defvar java-mode-map ()
+ "Keymap used in java-mode buffers.")
+(if java-mode-map
+ nil
+ (setq java-mode-map (c-make-inherited-keymap))
+ ;; add bindings which are only useful for Java
+ (define-key java-mode-map "/" 'c-electric-slash))
+
+(defvar java-mode-syntax-table nil
+ "Syntax table used in java-mode buffers.")
+(if java-mode-syntax-table
+ ()
+ (setq java-mode-syntax-table (make-syntax-table))
+ (c-populate-syntax-table java-mode-syntax-table)
+ ;; add extra comment syntax
+ (c-setup-dual-comments java-mode-syntax-table)
+ ;; everyone gets these
+ (modify-syntax-entry ?@ "_" java-mode-syntax-table)
+ )
+
+(easy-menu-define c-java-menu java-mode-map "Java Mode Commands"
+ (c-mode-menu "Java"))
+
+\f
+(provide 'cc-langs)
+;;; cc-langs.el ends here
--- /dev/null
+;;; cc-menus.el --- imenu support for CC Mode
+
+;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
+
+;; Authors: 1992-1997 Barry A. Warsaw
+;; 1987 Dave Detlefs and Stewart Clamen
+;; 1985 Richard M. Stallman
+;; Maintainer: cc-mode-help@python.org
+;; Created: 22-Apr-1997 (split from cc-mode.el)
+;; Version: 5.12
+;; 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.
+
+\f
+;; imenu integration
+(defvar cc-imenu-c++-generic-expression
+ (`
+ ((nil
+ (,
+ (concat
+ "^" ; beginning of line is required
+ "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
+ "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; type specs; there can be no
+ "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; more than 3 tokens, right?
+
+ "\\(" ; last type spec including */&
+ "[a-zA-Z0-9_:]+"
+ "\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)" ; either ptr/ref sign or ws
+ "\\)?" ; if there is a last type spec
+ "\\(" ; name, take into the imenu entry
+ "[a-zA-Z0-9_:~]+" ; member func, ctor or dtor...
+ ; (may not contain * because then
+ ; "a::operator char*" would
+ ; become "char*"!)
+ "\\|"
+ "\\([a-zA-Z0-9_:~]*::\\)?operator"
+ "[^a-zA-Z1-9_][^(]*" ; ...or operator
+ " \\)"
+ "[ \t]*([^)]*)[ \t\n]*[^ ;]" ; require something other than
+ ; a `;' after the (...) to
+ ; avoid prototypes. Can't
+ ; catch cases with () inside
+ ; the parentheses surrounding
+ ; the parameters. e.g.:
+ ; "int foo(int a=bar()) {...}"
+
+ )) 6)
+ ("Class"
+ (, (concat
+ "^" ; beginning of line is required
+ "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
+ "class[ \t]+"
+ "\\([a-zA-Z0-9_]+\\)" ; the string we want to get
+ "[ \t]*[:{]"
+ )) 2)))
+ "Imenu generic expression for C++ mode. See `imenu-generic-expression'.")
+
+(defvar cc-imenu-c-generic-expression
+ cc-imenu-c++-generic-expression
+ "Imenu generic expression for C mode. See `imenu-generic-expression'.")
+
+;(defvar cc-imenu-objc-generic-expression
+; ())
+; Please contribute one!
+
+(defvar cc-imenu-java-generic-expression
+ (`
+ ((nil
+ (,
+ (concat
+ "^\\([ \t]\\)*"
+ "\\([A-Za-z0-9_-]+[ \t]+\\)?" ; type specs; there can be
+ "\\([A-Za-z0-9_-]+[ \t]+\\)?" ; more than 3 tokens, right?
+ "\\([A-Za-z0-9_-]+[ \t]*[[]?[]]?\\)"
+ "\\([ \t]\\)"
+ "\\([A-Za-z0-9_-]+\\)" ; the string we want to get
+ "\\([ \t]*\\)+("
+ "\\([a-zA-Z,_1-9\n \t]*[[]?[]]?\\)*" ; arguments
+ ")[ \t]*"
+ "[^;(]"
+ "[,a-zA-Z_1-9\n \t]*{"
+ )) 6)))
+ "Imenu generic expression for Java mode. See `imenu-generic-expression'.")
+
+\f
+(provide 'cc-menus)
+;;; cc-menus.el ends here
--- /dev/null
+;;; cc-mode.el --- major mode for editing C, C++, Objective-C, and Java code
+
+;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
+
+;; Authors: 1992-1997 Barry A. Warsaw
+;; 1987 Dave Detlefs and Stewart Clamen
+;; 1985 Richard M. Stallman
+;; Maintainer: cc-mode-help@python.org
+;; Created: a long, long, time ago. adapted from the original c-mode.el
+;; Version: 5.12
+;; Keywords: c languages oop
+
+;; NOTE: Read the commentary below for the right way to submit bug reports!
+;; NOTE: See the accompanying texinfo manual for details on using this mode!
+
+;; 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:
+
+;; This package provides GNU Emacs major modes for editing C, C++,
+;; Objective-C, and Java code. As of the latest Emacs and XEmacs
+;; releases, it is the default package for editing these languages.
+;; This package is called "CC Mode", and should be spelled exactly
+;; this way. It supports K&R and ANSI C, ANSI C++, Objective-C, and
+;; Java, with a consistent indentation model across all modes. This
+;; indentation model is intuitive and very flexible, so that almost
+;; any desired style of indentation can be supported. Installation,
+;; usage, and programming details are contained in an accompanying
+;; texinfo manual.
+
+;; CC Mode's immediate ancestors were, c++-mode.el, cplus-md.el, and
+;; cplus-md1.el..
+
+;; NOTE: This mode does not perform font-locking (a.k.a syntactic
+;; coloring, keyword highlighting, etc.) for any of the supported
+;; modes. Typically this is done by a package called font-lock.el
+;; which I do *not* maintain. You should contact the Emacs
+;; maintainers for questions about coloring or highlighting in any
+;; language mode.
+
+;; To submit bug reports, type "C-c C-b". These will be sent to
+;; bug-gnu-emacs@prep.ai.mit.edu as well as cc-mode-help@python.org,
+;; and I'll read about them there (the former is mirrored as the
+;; Usenet newsgroup gnu.emacs.bug). Questions can sent to
+;; help-gnu-emacs@prep.ai.mit.edu (mirrored as gnu.emacs.help) and/or
+;; cc-mode-help@python.org. Please do not send bugs or questions to
+;; my personal account.
+
+;; YOU CAN IGNORE ALL BYTE-COMPILER WARNINGS. They are the result of
+;; the cross-Emacsen support. GNU Emacs 19 (from the FSF), GNU XEmacs
+;; 19 (formerly Lucid Emacs), and GNU Emacs 18 all do things
+;; differently and there's no way to shut the byte-compiler up at the
+;; necessary granularity. Let me say this again: YOU CAN IGNORE ALL
+;; BYTE-COMPILER WARNINGS (you'd be surprised at how many people don't
+;; follow this advice :-).
+
+;; Many, many thanks go out to all the folks on the beta test list.
+;; Without their patience, testing, insight, code contributions, and
+;; encouragement CC Mode would be a far inferior package.
+
+;; You can get the latest version of CC Mode, including PostScript
+;; documentation and separate individual files from:
+;;
+;; http://www.python.org/ftp/emacs/
+
+;; Or if you don't have access to the World Wide Web, through
+;; anonymous ftp from:
+;;
+;; ftp://ftp.python.org/pub/emacs
+
+;;; Code:
+
+(eval-when-compile
+ (require 'cc-menus))
+(require 'cc-defs)
+
+\f
+;;;###autoload
+(defun c-mode ()
+ "Major mode for editing K&R and ANSI C code.
+To submit a problem report, enter `\\[c-submit-bug-report]' from a
+c-mode buffer. This automatically sets up a mail buffer with version
+information already added. You just need to add a description of the
+problem, including a reproducible test case and send the message.
+
+To see what version of CC Mode you are running, enter `\\[c-version]'.
+
+The hook variable `c-mode-hook' is run with no args, if that value is
+bound and has a non-nil value. Also the hook `c-mode-common-hook' is
+run first.
+
+Key bindings:
+\\{c-mode-map}"
+ (interactive)
+ (c-load-all)
+ (kill-all-local-variables)
+ (set-syntax-table c-mode-syntax-table)
+ (setq major-mode 'c-mode
+ mode-name "C"
+ local-abbrev-table c-mode-abbrev-table)
+ (use-local-map c-mode-map)
+ (c-common-init)
+ (setq comment-start "/* "
+ comment-end " */"
+ comment-multi-line t
+ c-conditional-key c-C-conditional-key
+ c-class-key c-C-class-key
+ c-baseclass-key nil
+ c-comment-start-regexp c-C-comment-start-regexp
+ imenu-generic-expression cc-imenu-c-generic-expression)
+ (run-hooks 'c-mode-common-hook)
+ (run-hooks 'c-mode-hook)
+ (c-update-modeline))
+
+\f
+;;;###autoload
+(defun c++-mode ()
+ "Major mode for editing C++ code.
+To submit a problem report, enter `\\[c-submit-bug-report]' from a
+c++-mode buffer. This automatically sets up a mail buffer with
+version information already added. You just need to add a description
+of the problem, including a reproducible test case, and send the
+message.
+
+To see what version of CC Mode you are running, enter `\\[c-version]'.
+
+The hook variable `c++-mode-hook' is run with no args, if that
+variable is bound and has a non-nil value. Also the hook
+`c-mode-common-hook' is run first.
+
+Key bindings:
+\\{c++-mode-map}"
+ (interactive)
+ (c-load-all)
+ (kill-all-local-variables)
+ (set-syntax-table c++-mode-syntax-table)
+ (setq major-mode 'c++-mode
+ mode-name "C++"
+ local-abbrev-table c++-mode-abbrev-table)
+ (use-local-map c++-mode-map)
+ (c-common-init)
+ (setq comment-start "// "
+ comment-end ""
+ comment-multi-line nil
+ c-conditional-key c-C++-conditional-key
+ c-comment-start-regexp c-C++-comment-start-regexp
+ c-class-key c-C++-class-key
+ c-access-key c-C++-access-key
+ c-double-slash-is-comments-p t
+ c-recognize-knr-p nil
+ imenu-generic-expression cc-imenu-c++-generic-expression)
+ (run-hooks 'c-mode-common-hook)
+ (run-hooks 'c++-mode-hook)
+ (c-update-modeline))
+
+\f
+;;;###autoload
+(defun objc-mode ()
+ "Major mode for editing Objective C code.
+To submit a problem report, enter `\\[c-submit-bug-report]' from an
+objc-mode buffer. This automatically sets up a mail buffer with
+version information already added. You just need to add a description
+of the problem, including a reproducible test case, and send the
+message.
+
+To see what version of CC Mode you are running, enter `\\[c-version]'.
+
+The hook variable `objc-mode-hook' is run with no args, if that value
+is bound and has a non-nil value. Also the hook `c-mode-common-hook'
+is run first.
+
+Key bindings:
+\\{objc-mode-map}"
+ (interactive)
+ (c-load-all)
+ (kill-all-local-variables)
+ (set-syntax-table objc-mode-syntax-table)
+ (setq major-mode 'objc-mode
+ mode-name "ObjC"
+ local-abbrev-table objc-mode-abbrev-table)
+ (use-local-map objc-mode-map)
+ (c-common-init)
+ (setq comment-start "// "
+ comment-end ""
+ comment-multi-line nil
+ c-conditional-key c-C-conditional-key
+ c-comment-start-regexp c-C++-comment-start-regexp
+ c-class-key c-ObjC-class-key
+ c-baseclass-key nil
+ c-access-key c-ObjC-access-key
+ c-double-slash-is-comments-p t
+ c-method-key c-ObjC-method-key)
+ (run-hooks 'c-mode-common-hook)
+ (run-hooks 'objc-mode-hook)
+ (c-update-modeline))
+
+\f
+;;;###autoload
+(defun java-mode ()
+ "Major mode for editing Java code.
+To submit a problem report, enter `\\[c-submit-bug-report]' from an
+java-mode buffer. This automatically sets up a mail buffer with
+version information already added. You just need to add a description
+of the problem, including a reproducible test case and send the
+message.
+
+To see what version of CC Mode you are running, enter `\\[c-version]'.
+
+The hook variable `java-mode-hook' is run with no args, if that value
+is bound and has a non-nil value. Also the common hook
+`c-mode-common-hook' is run first. Note that this mode automatically
+sets the \"java\" style before calling any hooks so be careful if you
+set styles in `c-mode-common-hook'.
+
+Key bindings:
+\\{java-mode-map}"
+ (interactive)
+ (c-load-all)
+ (kill-all-local-variables)
+ (set-syntax-table java-mode-syntax-table)
+ (setq major-mode 'java-mode
+ mode-name "Java"
+ local-abbrev-table java-mode-abbrev-table)
+ (use-local-map java-mode-map)
+ (c-common-init)
+ (setq comment-start "// "
+ comment-end ""
+ comment-multi-line nil
+ c-conditional-key c-Java-conditional-key
+ c-comment-start-regexp c-Java-comment-start-regexp
+ c-class-key c-Java-class-key
+ c-method-key c-Java-method-key
+ c-double-slash-is-comments-p t
+ c-baseclass-key nil
+ c-recognize-knr-p nil
+ c-access-key c-Java-access-key
+ ;defun-prompt-regexp c-Java-defun-prompt-regexp
+ imenu-generic-expression cc-imenu-java-generic-expression
+ )
+ (c-set-style "java")
+ (run-hooks 'c-mode-common-hook)
+ (run-hooks 'java-mode-hook)
+ (c-update-modeline))
+
+\f
+;; defuns for submitting bug reports
+(defconst c-version "5.12"
+ "CC Mode version number.")
+
+(defconst c-mode-help-address
+ "bug-gnu-emacs@prep.ai.mit.edu, cc-mode-help@python.org"
+ "Address for CC Mode bug reports.")
+
+(defun c-version ()
+ "Echo the current version of CC Mode in the minibuffer."
+ (interactive)
+ (message "Using CC Mode version %s" c-version)
+ (c-keep-region-active))
+
+;; Get reporter-submit-bug-report when byte-compiling
+(eval-when-compile
+ (require 'reporter))
+
+(defun c-submit-bug-report ()
+ "Submit via mail a bug report on CC Mode."
+ (interactive)
+ (require 'cc-vars)
+ ;; load in reporter
+ (let ((reporter-prompt-for-summary-p t)
+ (reporter-dont-compact-list '(c-offsets-alist))
+ (style c-indentation-style)
+ (hook c-special-indent-hook)
+ (c-features c-emacs-features))
+ (and
+ (if (y-or-n-p "Do you want to submit a report on CC Mode? ")
+ t (message "") nil)
+ (require 'reporter)
+ (reporter-submit-bug-report
+ c-mode-help-address
+ (concat "CC Mode " c-version " ("
+ (cond ((eq major-mode 'c++-mode) "C++")
+ ((eq major-mode 'c-mode) "C")
+ ((eq major-mode 'objc-mode) "ObjC")
+ ((eq major-mode 'java-mode) "Java")
+ )
+ ")")
+ (let ((vars (list
+ ;; report only the vars that affect indentation
+ 'c-basic-offset
+ 'c-offsets-alist
+ 'c-cleanup-list
+ 'c-comment-only-line-offset
+ 'c-backslash-column
+ 'c-delete-function
+ 'c-electric-pound-behavior
+ 'c-hanging-braces-alist
+ 'c-hanging-colons-alist
+ 'c-hanging-comment-starter-p
+ 'c-hanging-comment-ender-p
+ 'c-indent-comments-syntactically-p
+ 'c-tab-always-indent
+ 'c-recognize-knr-p
+ 'c-label-minimum-indentation
+ 'defun-prompt-regexp
+ 'tab-width
+ )))
+ (if (not (boundp 'defun-prompt-regexp))
+ (delq 'defun-prompt-regexp vars)
+ vars))
+ (function
+ (lambda ()
+ (insert
+ "Buffer Style: " style "\n\n"
+ (if hook
+ (concat "\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
+ "c-special-indent-hook is set to '"
+ (format "%s" hook)
+ ".\nPerhaps this is your problem?\n"
+ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n")
+ "\n")
+ (format "c-emacs-features: %s\n" c-features)
+ )))
+ nil
+ "Dear Barry,"
+ ))))
+
+\f
+(provide 'cc-mode)
+;;; cc-mode.el ends here
--- /dev/null
+;;; cc-styles.el --- support for styles in CC Mode
+
+;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
+
+;; Authors: 1992-1997 Barry A. Warsaw
+;; 1987 Dave Detlefs and Stewart Clamen
+;; 1985 Richard M. Stallman
+;; Maintainer: cc-mode-help@python.org
+;; Created: 22-Apr-1997 (split from cc-mode.el)
+;; Version: 5.12
+;; 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.
+
+
+\f
+(defconst 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 . +)
+ (label . 0)
+ (statement-case-open . +)
+ (statement-cont . +)
+ (arglist-intro . c-lineup-arglist-intro-after-paren)
+ (arglist-close . c-lineup-arglist)
+ ))
+ (c-special-indent-hook . c-gnu-impose-minimum)
+ )
+ ("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)
+ (label . 0)
+ (statement-cont . +)
+ ))
+ )
+ ("bsd"
+ (c-basic-offset . 4)
+ (c-comment-only-line-offset . 0)
+ (c-offsets-alist . ((statement-block-intro . +)
+ (knr-argdecl-intro . +)
+ (substatement-open . 0)
+ (label . 0)
+ (statement-cont . +)
+ ))
+ )
+ ("stroustrup"
+ (c-basic-offset . 4)
+ (c-comment-only-line-offset . 0)
+ (c-offsets-alist . ((statement-block-intro . +)
+ (substatement-open . 0)
+ (label . 0)
+ (statement-cont . +)
+ ))
+ )
+ ("whitesmith"
+ (c-basic-offset . 4)
+ (c-comment-only-line-offset . 0)
+ (c-offsets-alist . ((statement-block-intro . +)
+ (knr-argdecl-intro . +)
+ (substatement-open . 0)
+ (label . 0)
+ (statement-cont . +)
+ ))
+
+ )
+ ("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)
+ (topmost-intro-cont . 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)
+ (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)
+ (label . 0)
+ (statement-cont . +)
+ ))
+ )
+ ("python"
+ (indent-tabs-mode . t)
+ (fill-column . 72)
+ (c-basic-offset . 8)
+ (c-offsets-alist . ((substatement-open . 0)
+ ))
+ (c-hanging-braces-alist . ((brace-list-open)
+ (brace-list-intro)
+ (brace-list-close)
+ (substatement-open after)
+ (block-close . c-snug-do-while)
+ ))
+ )
+ ("java"
+ (c-basic-offset . 2)
+ (c-comment-only-line-offset . (0 . 0))
+ (c-offsets-alist . ((topmost-intro-cont . +)
+ (statement-block-intro . +)
+ (knr-argdecl-intro . 5)
+ (substatement-open . +)
+ (label . 0)
+ (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 \"cc-mode\" 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.")
+
+\f
+;; Functions that manipulate styles
+(defun c-set-style-1 (conscell)
+ ;; Set the style for one variable
+ (let ((attr (car conscell))
+ (val (cdr conscell)))
+ (cond
+ ;; first special variable
+ ((eq attr 'c-offsets-alist)
+ (mapcar
+ (function
+ (lambda (langentry)
+ (let ((langelem (car langentry))
+ (offset (cdr langentry)))
+ (c-set-offset langelem offset)
+ )))
+ val))
+ ;; second special variable
+ ((eq attr 'c-special-indent-hook)
+ (if (listp val)
+ (while val
+ (add-hook 'c-special-indent-hook (car val))
+ (setq val (cdr val)))
+ (add-hook 'c-special-indent-hook val)))
+ ;; all other variables
+ (t (set attr val)))
+ ))
+
+(defun c-set-style-2 (style basestyles)
+ ;; Recursively set the base style. If no base style is given, the
+ ;; default base style is "cc-mode" and the recursion stops. Be sure
+ ;; to detect loops.
+ (if (not (string-equal style "cc-mode"))
+ (let ((base (if (stringp (car basestyles))
+ (downcase (car basestyles))
+ "cc-mode")))
+ (if (memq base basestyles)
+ (error "Style loop detected: %s in %s" base basestyles))
+ (c-set-style-2 base (cons base basestyles))))
+ (let ((vars (cdr (or (assoc (downcase style) c-style-alist)
+ (assoc (upcase style) c-style-alist)
+ (assoc style c-style-alist)
+ (error "Undefined style: %s" style)))))
+ (mapcar 'c-set-style-1 vars)))
+
+(defvar c-set-style-history nil)
+
+;;;###autoload
+(defun c-set-style (stylename)
+ "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."
+ (interactive (list (let ((completion-ignore-case t)
+ (prompt (format "Which %s indentation style? "
+ mode-name)))
+ (completing-read prompt c-style-alist nil t
+ (cons c-indentation-style 0)
+ 'c-set-style-history))))
+ (c-set-style-2 stylename nil)
+ (setq c-indentation-style stylename)
+ (c-keep-region-active))
+
+;;;###autoload
+(defun c-add-style (style descrip &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. DESCRIP 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))
+ (description (eval-minibuffer "Style description: ")))
+ (list stylename description
+ (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 descrip)) ; replace
+ (setq c-style-alist (cons (cons style descrip) c-style-alist))))
+ (and set-p (c-set-style style)))
+
+
+\f
+(defconst c-offsets-alist
+ '((string . -1000)
+ (c . c-lineup-C-comments)
+ (defun-open . 0)
+ (defun-close . 0)
+ (defun-block-intro . +)
+ (class-open . 0)
+ (class-close . 0)
+ (inline-open . +)
+ (inline-close . 0)
+ (func-decl-cont . +)
+ (knr-argdecl-intro . +)
+ (knr-argdecl . 0)
+ (topmost-intro . 0)
+ (topmost-intro-cont . 0)
+ (member-init-intro . +)
+ (member-init-cont . 0)
+ (inher-intro . +)
+ (inher-cont . c-lineup-multi-inher)
+ (block-open . 0)
+ (block-close . 0)
+ (brace-list-open . 0)
+ (brace-list-close . 0)
+ (brace-list-intro . +)
+ (brace-list-entry . 0)
+ (statement . 0)
+ ;; some people might prefer
+ ;;(statement . c-lineup-runin-statements)
+ (statement-cont . +)
+ ;; some people might prefer
+ ;;(statement-cont . c-lineup-math)
+ (statement-block-intro . +)
+ (statement-case-intro . +)
+ (statement-case-open . 0)
+ (substatement . +)
+ (substatement-open . +)
+ (case-label . 0)
+ (access-label . -)
+ (label . 2)
+ (do-while-closure . 0)
+ (else-clause . 0)
+ (comment-intro . c-lineup-comment)
+ (arglist-intro . +)
+ (arglist-cont . 0)
+ (arglist-cont-nonempty . c-lineup-arglist)
+ (arglist-close . +)
+ (stream-op . c-lineup-streamop)
+ (inclass . +)
+ (cpp-macro . -1000)
+ (friend . 0)
+ (objc-method-intro . -1000)
+ (objc-method-args-cont . c-lineup-ObjC-method-args)
+ (objc-method-call-cont . c-lineup-ObjC-method-call)
+ (extern-lang-open . 0)
+ (extern-lang-close . 0)
+ (inextern-lang . +)
+ )
+ "Association list of syntactic element symbols and indentation offsets.
+As described below, each cons cell in this list has the form:
+
+ (SYNTACTIC-SYMBOL . OFFSET)
+
+When a line is indented, CC Mode first determines the syntactic
+context of the line by generating a list of symbols called syntactic
+elements. This list can contain more than one syntactic element and
+the global variable `c-syntactic-context' contains the context list
+for the line being indented. Each element in this list is actually a
+cons cell of the syntactic symbol and a buffer position. This buffer
+position is called the relative indent point for the line. Some
+syntactic symbols may not have a relative indent point associated with
+them.
+
+After the syntactic context list for a line is generated, CC Mode
+calculates the absolute indentation for the line by looking at each
+syntactic element in the list. First, it compares the syntactic
+element against the SYNTACTIC-SYMBOL's in `c-offsets-alist'. When it
+finds a match, it adds the OFFSET to the column of the relative indent
+point. The sum of this calculation for each element in the syntactic
+list is the absolute offset for line being indented.
+
+If the syntactic element does not match any in the `c-offsets-alist',
+an error is generated if `c-strict-syntax-p' is non-nil, otherwise the
+element is ignored.
+
+Actually, OFFSET can be an integer, a function, a variable, or one of
+the following symbols: `+', `-', `++', `--', `*', or `/'. These
+latter designate positive or negative multiples of `c-basic-offset',
+respectively: 1, -1, 2, -2, 0.5, and -0.5. If OFFSET is a function, it
+is called with a single argument containing the cons of the syntactic
+element symbol and the relative indent point. The function should
+return an integer offset.
+
+Here is the current list of valid syntactic element symbols:
+
+ string -- inside multi-line string
+ c -- inside a multi-line C style block comment
+ defun-open -- brace that opens a function definition
+ defun-close -- brace that closes a function definition
+ defun-block-intro -- the first line in a top-level defun
+ class-open -- brace that opens a class definition
+ class-close -- brace that closes a class definition
+ inline-open -- brace that opens an in-class inline method
+ inline-close -- brace that closes an in-class inline method
+ func-decl-cont -- the region between a function definition's
+ argument list and the function opening brace
+ (excluding K&R argument declarations). In C, you
+ cannot put anything but whitespace and comments
+ between them; in C++ and Java, throws declarations
+ and other things can appear in this context.
+ knr-argdecl-intro -- first line of a K&R C argument declaration
+ knr-argdecl -- subsequent lines in a K&R C argument declaration
+ topmost-intro -- the first line in a topmost construct definition
+ topmost-intro-cont -- topmost definition continuation lines
+ member-init-intro -- first line in a member initialization list
+ member-init-cont -- subsequent member initialization list lines
+ inher-intro -- first line of a multiple inheritance list
+ inher-cont -- subsequent multiple inheritance lines
+ block-open -- statement block open brace
+ block-close -- statement block close brace
+ brace-list-open -- open brace of an enum or static array list
+ brace-list-close -- close brace of an enum or static array list
+ brace-list-intro -- first line in an enum or static array list
+ brace-list-entry -- subsequent lines in an enum or static array list
+ statement -- a C (or like) statement
+ statement-cont -- a continuation of a C (or like) statement
+ statement-block-intro -- the first line in a new statement block
+ statement-case-intro -- the first line in a case \"block\"
+ statement-case-open -- the first line in a case block starting with brace
+ substatement -- the first line after an if/while/for/do/else
+ substatement-open -- the brace that opens a substatement block
+ case-label -- a `case' or `default' label
+ access-label -- C++ private/protected/public access label
+ label -- any ordinary label
+ do-while-closure -- the `while' that ends a do/while construct
+ else-clause -- the `else' of an if/else construct
+ comment-intro -- a line containing only a comment introduction
+ arglist-intro -- the first line in an argument list
+ arglist-cont -- subsequent argument list lines when no
+ arguments follow on the same line as the
+ arglist opening paren
+ arglist-cont-nonempty -- subsequent argument list lines when at
+ least one argument follows on the same
+ line as the arglist opening paren
+ arglist-close -- the solo close paren of an argument list
+ stream-op -- lines continuing a stream operator construct
+ inclass -- the construct is nested inside a class definition
+ cpp-macro -- the start of a cpp macro
+ friend -- a C++ friend declaration
+ objc-method-intro -- the first line of an Objective-C method definition
+ objc-method-args-cont -- lines continuing an Objective-C method definition
+ objc-method-call-cont -- lines continuing an Objective-C method call
+ extern-lang-open -- brace that opens an external language block
+ extern-lang-close -- brace that closes an external language block
+ inextern-lang -- analogous to `inclass' syntactic symbol
+")
+
+(defun c-get-offset (langelem)
+ ;; Get offset from LANGELEM which is a cons cell of the form:
+ ;; (SYMBOL . RELPOS). The symbol is matched against
+ ;; c-offsets-alist and the offset found there is either returned,
+ ;; or added to the indentation at RELPOS. If RELPOS is nil, then
+ ;; the offset is simply returned.
+ (let* ((symbol (car langelem))
+ (relpos (cdr langelem))
+ (match (assq symbol c-offsets-alist))
+ (offset (cdr-safe match)))
+ ;; offset can be a number, a function, a variable, or one of the
+ ;; symbols + or -
+ (cond
+ ((not match)
+ (if c-strict-syntax-p
+ (error "don't know how to indent a %s" symbol)
+ (setq offset 0
+ relpos 0)))
+ ((eq offset '+) (setq offset c-basic-offset))
+ ((eq offset '-) (setq offset (- c-basic-offset)))
+ ((eq offset '++) (setq offset (* 2 c-basic-offset)))
+ ((eq offset '--) (setq offset (* 2 (- c-basic-offset))))
+ ((eq offset '*) (setq offset (/ c-basic-offset 2)))
+ ((eq offset '/) (setq offset (/ (- c-basic-offset) 2)))
+ ((functionp offset) (setq offset (funcall offset langelem)))
+ ((not (numberp offset)) (setq offset (symbol-value offset)))
+ )
+ (+ (if (and relpos
+ (< relpos (c-point 'bol)))
+ (save-excursion
+ (goto-char relpos)
+ (current-column))
+ 0)
+ offset)))
+
+\f
+(defvar c-read-offset-history nil)
+
+(defun c-read-offset (langelem)
+ ;; read new offset value for LANGELEM from minibuffer. return a
+ ;; legal value only
+ (let* ((oldoff (cdr-safe (assq langelem c-offsets-alist)))
+ (defstr (format "(default %s): " oldoff))
+ (errmsg (concat "Offset must be int, func, var, "
+ "or in [+,-,++,--,*,/] "
+ defstr))
+ (prompt (concat "Offset " defstr))
+ offset input interned raw)
+ (while (not offset)
+ (setq input (completing-read prompt obarray 'fboundp nil nil
+ 'c-read-offset-history)
+ offset (cond ((string-equal "" input) oldoff) ; default
+ ((string-equal "+" input) '+)
+ ((string-equal "-" input) '-)
+ ((string-equal "++" input) '++)
+ ((string-equal "--" input) '--)
+ ((string-equal "*" input) '*)
+ ((string-equal "/" input) '/)
+ ((string-match "^-?[0-9]+$" input)
+ (string-to-int input))
+ ;; a symbol with a function binding
+ ((fboundp (setq interned (intern input)))
+ interned)
+ ;; a lambda function
+ ((c-safe (functionp (setq raw (read input))))
+ raw)
+ ;; a symbol with variable binding
+ ((boundp interned) interned)
+ ;; error, but don't signal one, keep trying
+ ;; to read an input value
+ (t (ding)
+ (setq prompt errmsg)
+ nil))))
+ offset))
+
+(defun c-set-offset (symbol offset &optional add-p)
+ "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. Optional ADD says to add SYMBOL to
+`c-offsets-alist' if it doesn't already appear there."
+ (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))
+ c-offsets-alist)
+ nil (not current-prefix-arg)
+ ;; initial contents tries to be the last element
+ ;; on the syntactic analysis list for the current
+ ;; line
+ (let* ((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
+ (or (eq offset '+)
+ (eq offset '-)
+ (eq offset '++)
+ (eq offset '--)
+ (eq offset '*)
+ (eq offset '/)
+ (integerp offset)
+ (functionp offset)
+ (boundp offset)
+ (error "Offset must be int, func, var, or in [+,-,++,--,*,/]: %s"
+ offset))
+ (let ((entry (assq symbol c-offsets-alist)))
+ (if entry
+ (setcdr entry offset)
+ (if add-p
+ (setq c-offsets-alist (cons (cons symbol offset) c-offsets-alist))
+ (error "%s is not a valid syntactic symbol." symbol))))
+ (c-keep-region-active))
+
+
+\f
+(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!
+ (require 'cl)
+ (or (assoc "cc-mode" c-style-alist)
+ (progn
+ (c-add-style "cc-mode"
+ (mapcar
+ (function
+ (lambda (var)
+ (let ((val (symbol-value var)))
+ (cons var (if (atom val) val
+ (copy-tree val)
+ ))
+ )))
+ '(c-backslash-column
+ c-basic-offset
+ c-cleanup-list
+ c-comment-only-line-offset
+ c-electric-pound-behavior
+ c-hanging-braces-alist
+ c-hanging-colons-alist
+ c-hanging-comment-starter-p
+ c-hanging-comment-ender-p
+ c-offsets-alist
+ )))
+ ;; the default style is now GNU. This can be overridden in
+ ;; c-mode-common-hook or {c,c++,objc,java}-mode-hook.
+ (c-set-style c-site-default-style))))
+
+(defun c-make-styles-buffer-local ()
+ "Make all CC Mode style variables buffer local.
+If you edit primarily one style of C (or C++, Objective-C, Java) code,
+you probably want style variables to be global. This is the default.
+
+If you edit many different styles of C (or C++, Objective-C, Java) at
+the same time, you probably want the CC Mode style variables to be
+buffer local. If you do, then you will need to set any CC Mode style
+variables in a hook function (e.g. off of c-mode-common-hook), instead
+of at the top level of your ~/.emacs file.
+
+This function makes all the CC Mode style variables buffer local.
+Call it after CC Mode is loaded into your Emacs environment.
+Conversely, set the variable `c-style-variables-are-local-p' to t in
+your .emacs file, before CC Mode is loaded, and this function will be
+automatically called when CC Mode is loaded."
+ ;; style variables
+ (make-variable-buffer-local 'c-offsets-alist)
+ (make-variable-buffer-local 'c-basic-offset)
+ (make-variable-buffer-local 'c-file-style)
+ (make-variable-buffer-local 'c-file-offsets)
+ (make-variable-buffer-local 'c-comment-only-line-offset)
+ (make-variable-buffer-local 'c-cleanup-list)
+ (make-variable-buffer-local 'c-hanging-braces-alist)
+ (make-variable-buffer-local 'c-hanging-colons-alist)
+ (make-variable-buffer-local 'c-hanging-comment-starter-p)
+ (make-variable-buffer-local 'c-hanging-comment-ender-p)
+ (make-variable-buffer-local 'c-backslash-column)
+ (make-variable-buffer-local 'c-label-minimum-indentation)
+ (make-variable-buffer-local 'c-special-indent-hook)
+ (make-variable-buffer-local 'c-indentation-style))
+
+\f
+(provide 'cc-styles)
+;;; cc-styles.el ends here
--- /dev/null
+;;; cc-vars.el --- user customization variables for CC Mode
+
+;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
+
+;; Authors: 1992-1997 Barry A. Warsaw
+;; 1987 Dave Detlefs and Stewart Clamen
+;; 1985 Richard M. Stallman
+;; Maintainer: cc-mode-help@python.org
+;; Created: 22-Apr-1997 (split from cc-mode.el)
+;; Version: 5.12
+;; 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.
+
+(require 'custom)
+
+\f
+(defcustom c-strict-syntax-p nil
+ "*If non-nil, all syntactic symbols must be found in `c-offsets-alist'.
+If the syntactic symbol for a particular line does not match a symbol
+in the offsets alist, an error is generated, otherwise no error is
+reported and the syntactic symbol is ignored."
+ :type 'boolean
+ :group 'c)
+
+(defcustom c-echo-syntactic-information-p nil
+ "*If non-nil, syntactic info is echoed when the line is indented."
+ :type 'boolean
+ :group 'c)
+
+(defcustom c-basic-offset 4
+ "*Amount of basic offset used by + and - symbols in `c-offsets-alist'."
+ :type 'integer
+ :group 'c)
+
+(defcustom c-tab-always-indent t
+ "*Controls the operation of the TAB key.
+If t, hitting TAB always just indents the current line. If nil,
+hitting TAB indents the current line if point is at the left margin or
+in the line's indentation, otherwise it insert a `real' tab character
+\(see note\). If other than nil or t, then tab is inserted only
+within literals -- defined as comments and strings -- and inside
+preprocessor directives, but line is always reindented.
+
+Note: The value of `indent-tabs-mode' will determine whether a real
+tab character will be inserted, or the equivalent number of space.
+When inserting a tab, actually the function stored in the variable
+`c-insert-tab-function' is called.
+
+Note: indentation of lines containing only comments is also controlled
+by the `c-comment-only-line-offset' variable."
+ :type '(radio
+ :extra-offset 8
+ :format "%{C Tab Always Indent%}:\n The TAB key:\n%v"
+ (const :tag "always indents, never inserts TAB" t)
+ (const :tag "indents in left margin, otherwise inserts TAB" nil)
+ (const :tag "inserts TAB in literals, otherwise indent" other))
+ :group 'c)
+
+(defcustom c-insert-tab-function 'insert-tab
+ "*Function used when inserting a tab for \\[TAB].
+Only used when `c-tab-always-indent' indicates a `real' tab character
+should be inserted. Value must be a function taking no arguments."
+ :type 'function
+ :group 'c)
+
+(defcustom c-comment-only-line-offset 0
+ "*Extra offset for line which contains only the start of a comment.
+Can contain an integer or a cons cell of the form:
+
+ (NON-ANCHORED-OFFSET . ANCHORED-OFFSET)
+
+Where NON-ANCHORED-OFFSET is the amount of offset given to
+non-column-zero anchored comment-only lines, and ANCHORED-OFFSET is
+the amount of offset to give column-zero anchored comment-only lines.
+Just an integer as value is equivalent to (<val> . -1000)."
+ :type '(choice (integer :tag "Non-anchored offset")
+ (cons :tag "Non-anchored & anchored offset"
+ :value (0 . 0)
+ :extra-offset 8
+ (integer :tag "Non-anchored offset")
+ (integer :tag "Anchored offset")))
+ :group 'c)
+
+(defcustom c-indent-comments-syntactically-p nil
+ "*Specifies how comment-only lines should be indented.
+When this variable is non-nil, comment-only lines are indented
+according to syntactic analysis via `c-offsets-alist', even when
+\\[indent-for-comment] is used."
+ :type 'boolean
+ :group 'c)
+
+(defcustom c-cleanup-list '(scope-operator)
+ "*List of various C/C++/ObjC constructs to \"clean up\".
+These clean ups only take place when the auto-newline feature is
+turned on, as evidenced by the `/a' or `/ah' appearing next to the
+mode name. Valid symbols are:
+
+ brace-else-brace -- cleans up `} else {' constructs by placing entire
+ construct on a single line. This clean up
+ only takes place when there is nothing but
+ white space between the braces and the `else'.
+ Clean up occurs when the open-brace after the
+ `else' is typed.
+ brace-elseif-brace -- similar to brace-else-brace, but cleans up
+ `} else if {' constructs.
+ empty-defun-braces -- cleans up empty defun braces by placing the
+ braces on the same line. Clean up occurs when
+ the defun closing brace is typed.
+ defun-close-semi -- cleans up the terminating semi-colon on defuns
+ by placing the semi-colon on the same line as
+ the closing brace. Clean up occurs when the
+ semi-colon is typed.
+ list-close-comma -- cleans up commas following braces in array
+ and aggregate initializers. Clean up occurs
+ when the comma is typed.
+ scope-operator -- cleans up double colons which may designate
+ a C++ scope operator split across multiple
+ lines. Note that certain C++ constructs can
+ generate ambiguous situations. This clean up
+ only takes place when there is nothing but
+ whitespace between colons. Clean up occurs
+ when the second colon is typed."
+ :type '(set
+ :extra-offset 8
+ (const :tag "Put `} else {' on one line" brace-else-brace)
+ (const :tag "Put `} else if {' on one line" brace-elseif-brace)
+ (const :tag "Put empty defun braces on one line" empty-defun-braces)
+ (const :tag "Put `},' in aggregates on one line" list-close-comma)
+ (const :tag "Put C++ style `::' on one line" scope-operator))
+ :group 'c)
+
+(defcustom c-hanging-braces-alist '((brace-list-open)
+ (substatement-open after)
+ (block-close . c-snug-do-while)
+ (extern-lang-open after)
+ )
+ "*Controls the insertion of newlines before and after braces.
+This variable contains an association list with elements of the
+following form: (SYNTACTIC-SYMBOL . ACTION).
+
+When a brace (either opening or closing) is inserted, the syntactic
+context it defines is looked up in this list, and if found, the
+associated ACTION is used to determine where newlines are inserted.
+If the context is not found, the default is to insert a newline both
+before and after the brace.
+
+SYNTACTIC-SYMBOL can be any of: defun-open, defun-close, class-open,
+class-close, inline-open, inline-close, block-open, block-close,
+substatement-open, statement-case-open, extern-lang-open,
+extern-lang-close, brace-list-open, brace-list-close,
+brace-list-intro, or brace-list-entry. See `c-offsets-alist' for
+details.
+
+ACTION can be either a function symbol or a list containing any
+combination of the symbols `before' or `after'. If the list is empty,
+no newlines are inserted either before or after the brace.
+
+When ACTION is a function symbol, the function is called with a two
+arguments: the syntactic symbol for the brace and the buffer position
+at which the brace was inserted. The function must return a list as
+described in the preceding paragraph. Note that during the call to
+the function, the variable `c-syntactic-context' is set to the entire
+syntactic context for the brace line."
+ :type '(repeat
+ (cons :format "%v"
+ (choice :tag "Syntax"
+ (const defun-open) (const defun-close)
+ (const class-open) (const class-close)
+ (const inline-open) (const inline-close)
+ (const block-open) (const block-close)
+ (const substatement-open) (const statement-case-open)
+ (const extern-lang-open) (const extern-lang-close)
+ (const brace-list-open) (const brace-list-close)
+ (const brace-list-intro) (const brace-list-entry))
+ (choice :tag "Action"
+ (set :format "Insert a newline %v"
+ :extra-offset 38
+ (const :tag "before brace" before)
+ (const :tag "after brace" after))
+ (function :format "Run function %v" :value c-)
+ )))
+ :group 'c)
+
+(defcustom c-hanging-colons-alist nil
+ "*Controls the insertion of newlines before and after certain colons.
+This variable contains an association list with elements of the
+following form: (SYNTACTIC-SYMBOL . ACTION).
+
+SYNTACTIC-SYMBOL can be any of: case-label, label, access-label,
+member-init-intro, or inher-intro.
+
+See the variable `c-hanging-braces-alist' for the semantics of this
+variable. Note however that making ACTION a function symbol is
+currently not supported for this variable."
+ :type '(repeat
+ (cons :format "%v"
+ (choice :tag "Syntax"
+ (const case-label) (const label) (const access-label)
+ (const member-init-intro) (const inher-intro))
+ (set :tag "Action"
+ :format "%t: %v"
+ :extra-offset 8
+ (const before) (const after))))
+ :group 'c)
+
+(defcustom c-hanging-semi&comma-criteria '(c-semi&comma-inside-parenlist)
+ "*List of functions that decide whether to insert a newline or not.
+The functions in this list are called, in order, whenever the
+auto-newline minor mode is activated (as evidenced by a `/a' or `/ah'
+string in the mode line), and a semicolon or comma is typed (see
+`c-electric-semi&comma'). Each function in this list is called with
+no arguments, and should return one of the following values:
+
+ nil -- no determination made, continue checking
+ 'stop -- do not insert a newline, and stop checking
+ (anything else) -- insert a newline, and stop checking
+
+If every function in the list is called with no determination made,
+then no newline is inserted."
+ :type '(repeat function)
+ :group 'c)
+
+(defcustom c-hanging-comment-ender-p t
+ "*Controls what \\[fill-paragraph] does to C block comment enders.
+When set to nil, C block comment enders are left on their own line.
+When set to t, block comment enders will be placed at the end of the
+previous line (i.e. they `hang' on that line)."
+ :type 'boolean
+ :group 'c)
+
+(defcustom c-hanging-comment-starter-p t
+ "*Controls what \\[fill-paragraph] does to C block comment starters.
+When set to nil, C block comment starters are left on their own line.
+When set to t, text that follows a block comment starter will be
+placed on the same line as the block comment starter (i.e. the text
+`hangs' on that line)."
+ :type 'boolean
+ :group 'c)
+
+(defcustom c-backslash-column 48
+ "*Column to insert backslashes when macroizing a region."
+ :type 'integer
+ :group 'c)
+
+(defcustom c-special-indent-hook nil
+ "*Hook for user defined special indentation adjustments.
+This hook gets called after a line is indented by the mode."
+ :type 'hook
+ :group 'c)
+
+(defcustom c-backspace-function 'backward-delete-char-untabify
+ "*Function called by `c-electric-backspace' when deleting backwards."
+ :type 'function
+ :group 'c)
+
+(defcustom c-delete-function 'delete-char
+ "*Function called by `c-electric-delete' when deleting forwards."
+ :type 'function
+ :group 'c)
+
+(defcustom c-electric-pound-behavior nil
+ "*List of behaviors for electric pound insertion.
+Only currently supported behavior is `alignleft'."
+ :type '(set :extra-offset 8 (const alignleft))
+ :group 'c)
+
+(defcustom c-label-minimum-indentation 1
+ "*Minimum indentation for lines inside of top-level constructs.
+This variable typically only affects code using the `gnu' style, which
+mandates a minimum of one space in front of every line inside
+top-level constructs. Specifically, the function
+`c-gnu-impose-minimum' on your `c-special-indent-hook' is what
+enforces this."
+ :type 'integer
+ :group 'c)
+
+(defcustom c-progress-interval 5
+ "*Interval used to update progress status during long re-indentation.
+If a number, percentage complete gets updated after each interval of
+that many seconds. Set to nil to inhibit updating. This is only
+useful for Emacs 19."
+ :type 'integer
+ :group 'c)
+
+(defcustom c-site-default-style "gnu"
+ "Default style for your site.
+To change the default style at your site, you can set this variable to
+any style defined in `c-style-alist'. However, if CC Mode is usually
+loaded into your Emacs at compile time, you will need to set this
+variable in the `site-init.el' file before CC Mode is loaded, then
+re-dump Emacs."
+ :type 'string
+ :group 'c)
+
+(defcustom c-style-variables-are-local-p nil
+ "*Whether style variables should be buffer local by default.
+If non-nil, then all indentation style related variables will be made
+buffer local by default. If nil, they will remain global. Variables
+are made buffer local when this file is loaded, and once buffer
+localized, they cannot be made global again.
+
+The list of variables to buffer localize are:
+ c-offsets-alist
+ c-basic-offset
+ c-file-style
+ c-file-offsets
+ c-comment-only-line-offset
+ c-cleanup-list
+ c-hanging-braces-alist
+ c-hanging-colons-alist
+ c-hanging-comment-starter-p
+ c-hanging-comment-ender-p
+ c-backslash-column
+ c-label-minimum-indentation
+ c-special-indent-hook
+ c-indentation-style"
+ :type 'boolean
+ :group 'c)
+
+(defcustom c-mode-hook nil
+ "*Hook called by `c-mode'."
+ :type '(hook :format "%{C Mode Hook%}:\n%v")
+ :group 'c)
+
+(defcustom c++-mode-hook nil
+ "*Hook called by `c++-mode'."
+ :type 'hook
+ :group 'c)
+
+(defcustom objc-mode-hook nil
+ "*Hook called by `objc-mode'."
+ :type 'hook
+ :group 'c)
+
+(defcustom java-mode-hook nil
+ "*Hook called by `java-mode'."
+ :type 'hook
+ :group 'c)
+
+(defcustom c-mode-common-hook nil
+ "*Hook called by all CC Mode modes for common initializations."
+ :type '(hook :format "%{CC Mode Common Hook%}:\n%v")
+ :group 'c)
+
+
+\f
+;; Non-customizable variables, still part of the interface to CC Mode
+(defvar c-file-style nil
+ "Variable interface for setting style via File Local Variables.
+In a file's Local Variable section, you can set this variable to a
+string suitable for `c-set-style'. When the file is visited, CC Mode
+will set the style of the file to this value automatically.
+
+Note that file style settings are applied before file offset settings
+as designated in the variable `c-file-offsets'.")
+
+(defvar c-file-offsets nil
+ "Variable interface for setting offsets via File Local Variables.
+In a file's Local Variable section, you can set this variable to an
+association list similar to the values allowed in `c-offsets-alist'.
+When the file is visited, CC Mode will institute these offset settings
+automatically.
+
+Note that file offset settings are applied after file style settings
+as designated in the variable `c-file-style'.")
+
+(defvar c-syntactic-context nil
+ "Variable containing syntactic analysis list during indentation.")
+
+(defvar c-indentation-style c-site-default-style
+ "Name of style installed in the current buffer.")
+
+\f
+(provide 'cc-vars)
+;;; cc-vars.el ends here