Mercurial > emacs
changeset 18720:fc6d08b9bbe2
Initial revision
| author | Richard M. Stallman <rms@gnu.org> |
|---|---|
| date | Thu, 10 Jul 1997 07:54:06 +0000 |
| parents | de8249499f33 |
| children | 3344829154b9 |
| files | lisp/progmodes/cc-align.el lisp/progmodes/cc-cmds.el lisp/progmodes/cc-compat.el lisp/progmodes/cc-defs.el lisp/progmodes/cc-engine.el lisp/progmodes/cc-langs.el lisp/progmodes/cc-menus.el lisp/progmodes/cc-mode.el lisp/progmodes/cc-styles.el lisp/progmodes/cc-vars.el |
| diffstat | 10 files changed, 5805 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/progmodes/cc-align.el Thu Jul 10 07:54:06 1997 +0000 @@ -0,0 +1,392 @@ +;;; 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)) + + +;; 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))) + )) + )))) + + +;; 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))) + + +(provide 'cc-align) +;;; cc-align.el ends here
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/progmodes/cc-cmds.el Thu Jul 10 07:54:06 1997 +0000 @@ -0,0 +1,1369 @@ +;;; 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. + + +(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)) + + +;; 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)))) + + + +;; 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 "::")) + + +(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)) + + +;; 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 + + +;; 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))) + + +(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)) + + +;; 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))) + + +;; 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")))) + + + +;;; 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))))))) + + +(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))))) + + +(provide 'cc-cmds) +;;; cc-cmds.el ends here
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/progmodes/cc-compat.el Thu Jul 10 07:54:06 1997 +0000 @@ -0,0 +1,149 @@ +;;; 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)) + + +;; 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.") + + + +;; 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)) + + +(provide 'cc-compat) +;;; cc-compat.el ends here
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/progmodes/cc-defs.el Thu Jul 10 07:54:06 1997 +0000 @@ -0,0 +1,185 @@ +;;; 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. + + +;; 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.") + + + +(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)) + + +(provide 'cc-defs) +;;; cc-defs.el ends here
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/progmodes/cc-engine.el Thu Jul 10 07:54:06 1997 +0000 @@ -0,0 +1,1704 @@ +;;; 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. + + +;; 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)))))) + + + +(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)) + + +;; 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)) + ))) + ))) + + +;; 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))) + + +;; 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)) + + +(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)) + )) + + +(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)) + + +;; 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)))) + + +(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)) + + +(provide 'cc-engine) +;;; cc-engine.el ends here
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/progmodes/cc-langs.el Thu Jul 10 07:54:06 1997 +0000 @@ -0,0 +1,551 @@ +;;; 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. + + +;; 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_\\)+") + + +;; 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) + + +;; 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) + + +;; 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) + + +;; 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)) + + +;; 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) + + + +;; 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:;.,{}()=]*\\|\\([_$a-zA-Z][_$.a-zA-Z0-9]*\\)\\)\\s-*\\(([^);{}]*)\\)?\\([] \t]*\\)\\(\\s-*\\<throws\\>\\s-*\\(\\([_$a-zA-Z][_$.a-zA-Z0-9]*\\)[, \t\n\r\f]*\\)+\\)?\\s-*") + + + +;; 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) + + + +(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) + + +;; 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))) + + + +;; 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")) + + +;; 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++")) + + +;; 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")) + + +;; 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")) + + +(provide 'cc-langs) +;;; cc-langs.el ends here
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/progmodes/cc-menus.el Thu Jul 10 07:54:06 1997 +0000 @@ -0,0 +1,103 @@ +;;; 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. + + +;; 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'.") + + +(provide 'cc-menus) +;;; cc-menus.el ends here
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/progmodes/cc-mode.el Thu Jul 10 07:54:06 1997 +0000 @@ -0,0 +1,344 @@ +;;; 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) + + +;;;###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)) + + +;;;###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)) + + +;;;###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)) + + +;;;###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)) + + +;; 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," + )))) + + +(provide 'cc-mode) +;;; cc-mode.el ends here
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/progmodes/cc-styles.el Thu Jul 10 07:54:06 1997 +0000 @@ -0,0 +1,617 @@ +;;; 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. + + + +(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.") + + +;; 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))) + + + +(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))) + + +(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)) + + + +(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)) + + +(provide 'cc-styles) +;;; cc-styles.el ends here
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/progmodes/cc-vars.el Thu Jul 10 07:54:06 1997 +0000 @@ -0,0 +1,391 @@ +;;; 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) + + +(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) + + + +;; 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.") + + +(provide 'cc-vars) +;;; cc-vars.el ends here