![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c-mode.el CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / lisp|
Return to c-mode.el CVS log | Up to [Apple XNU] / GNUtools / emacs / lisp |
1.1 root 1: ;; C code editing commands for Emacs
2: ;; Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
3:
4: ;; This file is part of GNU Emacs.
5:
6: ;; GNU Emacs is free software; you can redistribute it and/or modify
7: ;; it under the terms of the GNU General Public License as published by
8: ;; the Free Software Foundation; either version 1, or (at your option)
9: ;; any later version.
10:
11: ;; GNU Emacs is distributed in the hope that it will be useful,
12: ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
13: ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: ;; GNU General Public License for more details.
15:
16: ;; You should have received a copy of the GNU General Public License
17: ;; along with GNU Emacs; see the file COPYING. If not, write to
18: ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
19:
20:
21: (defvar c-mode-abbrev-table nil
22: "Abbrev table in use in C-mode buffers.")
23: (define-abbrev-table 'c-mode-abbrev-table ())
24:
25: (defvar c-mode-map ()
26: "Keymap used in C mode.")
27: (if c-mode-map
28: ()
29: (setq c-mode-map (make-sparse-keymap))
30: (define-key c-mode-map "{" 'electric-c-brace)
31: (define-key c-mode-map "}" 'electric-c-brace)
32: (define-key c-mode-map ";" 'electric-c-semi)
33: (define-key c-mode-map ":" 'electric-c-terminator)
34: (define-key c-mode-map "\e\C-h" 'mark-c-function)
35: (define-key c-mode-map "\e\C-q" 'indent-c-exp)
36: (define-key c-mode-map "\177" 'backward-delete-char-untabify)
37: (define-key c-mode-map "\t" 'c-indent-command))
38:
39: (autoload 'c-macro-expand "cmacexp"
40: "Display the result of expanding all C macros occurring in the region.
41: The expansion is entirely correct because it uses the C preprocessor."
42: t)
43:
44: (defvar c-mode-syntax-table nil
45: "Syntax table in use in C-mode buffers.")
46:
47: (if c-mode-syntax-table
48: ()
49: (setq c-mode-syntax-table (make-syntax-table))
50: (modify-syntax-entry ?\\ "\\" c-mode-syntax-table)
51: (modify-syntax-entry ?/ ". 14" c-mode-syntax-table)
52: (modify-syntax-entry ?* ". 23" c-mode-syntax-table)
53: (modify-syntax-entry ?+ "." c-mode-syntax-table)
54: (modify-syntax-entry ?- "." c-mode-syntax-table)
55: (modify-syntax-entry ?= "." c-mode-syntax-table)
56: (modify-syntax-entry ?% "." c-mode-syntax-table)
57: (modify-syntax-entry ?< "." c-mode-syntax-table)
58: (modify-syntax-entry ?> "." c-mode-syntax-table)
59: (modify-syntax-entry ?& "." c-mode-syntax-table)
60: (modify-syntax-entry ?| "." c-mode-syntax-table)
61: (modify-syntax-entry ?\' "\"" c-mode-syntax-table))
62:
63: (defconst c-indent-level 2
64: "*Indentation of C statements with respect to containing block.")
65: (defconst c-brace-imaginary-offset 0
66: "*Imagined indentation of a C open brace that actually follows a statement.")
67: (defconst c-brace-offset 0
68: "*Extra indentation for braces, compared with other text in same context.")
69: (defconst c-argdecl-indent 5
70: "*Indentation level of declarations of C function arguments.")
71: (defconst c-label-offset -2
72: "*Offset of C label lines and case statements relative to usual indentation.")
73: (defconst c-continued-statement-offset 2
74: "*Extra indent for lines not starting new statements.")
75: (defconst c-continued-brace-offset 0
76: "*Extra indent for substatements that start with open-braces.
77: This is in addition to c-continued-statement-offset.")
78:
79: (defconst c-auto-newline nil
80: "*Non-nil means automatically newline before and after braces,
81: and after colons and semicolons, inserted in C code.")
82:
83: (defconst c-tab-always-indent t
84: "*Non-nil means TAB in C mode should always reindent the current line,
85: regardless of where in the line point is when the TAB command is used.")
86:
87: (defun c-mode ()
88: "Major mode for editing C code.
89: Expression and list commands understand all C brackets.
90: Tab indents for C code.
91: Comments are delimited with /* ... */.
92: Paragraphs are separated by blank lines only.
93: Delete converts tabs to spaces as it moves back.
94: \\{c-mode-map}
95: Variables controlling indentation style:
96: c-tab-always-indent
97: Non-nil means TAB in C mode should always reindent the current line,
98: regardless of where in the line point is when the TAB command is used.
99: c-auto-newline
100: Non-nil means automatically newline before and after braces,
101: and after colons and semicolons, inserted in C code.
102: c-indent-level
103: Indentation of C statements within surrounding block.
104: The surrounding block's indentation is the indentation
105: of the line on which the open-brace appears.
106: c-continued-statement-offset
107: Extra indentation given to a substatement, such as the
108: then-clause of an if or body of a while.
109: c-continued-brace-offset
110: Extra indentation given to a brace that starts a substatement.
111: This is in addition to c-continued-statement-offset.
112: c-brace-offset
113: Extra indentation for line if it starts with an open brace.
114: c-brace-imaginary-offset
115: An open brace following other text is treated as if it were
116: this far to the right of the start of its line.
117: c-argdecl-indent
118: Indentation level of declarations of C function arguments.
119: c-label-offset
120: Extra indentation for line that is a label, or case or default.
121:
122: Settings for K&R and BSD indentation styles are
123: c-indent-level 5 8
124: c-continued-statement-offset 5 8
125: c-brace-offset -5 -8
126: c-argdecl-indent 0 8
127: c-label-offset -5 -8
128:
129: Turning on C mode calls the value of the variable c-mode-hook with no args,
130: if that value is non-nil."
131: (interactive)
132: (kill-all-local-variables)
133: (use-local-map c-mode-map)
134: (setq major-mode 'c-mode)
135: (setq mode-name "C")
136: (setq local-abbrev-table c-mode-abbrev-table)
137: (set-syntax-table c-mode-syntax-table)
138: (make-local-variable 'paragraph-start)
139: (setq paragraph-start (concat "^$\\|" page-delimiter))
140: (make-local-variable 'paragraph-separate)
141: (setq paragraph-separate paragraph-start)
142: (make-local-variable 'paragraph-ignore-fill-prefix)
143: (setq paragraph-ignore-fill-prefix t)
144: (make-local-variable 'indent-line-function)
145: (setq indent-line-function 'c-indent-line)
146: (make-local-variable 'require-final-newline)
147: (setq require-final-newline t)
148: (make-local-variable 'comment-start)
149: (setq comment-start "/* ")
150: (make-local-variable 'comment-end)
151: (setq comment-end " */")
152: (make-local-variable 'comment-column)
153: (setq comment-column 32)
154: (make-local-variable 'comment-start-skip)
155: (setq comment-start-skip "/\\*+ *")
156: (make-local-variable 'comment-indent-hook)
157: (setq comment-indent-hook 'c-comment-indent)
158: (make-local-variable 'parse-sexp-ignore-comments)
159: (setq parse-sexp-ignore-comments t)
160: (run-hooks 'c-mode-hook))
161:
162: ;; This is used by indent-for-comment
163: ;; to decide how much to indent a comment in C code
164: ;; based on its context.
165: (defun c-comment-indent ()
166: (if (looking-at "^/\\*")
167: 0 ;Existing comment at bol stays there.
168: (save-excursion
169: (skip-chars-backward " \t")
170: (max (1+ (current-column)) ;Else indent at comment column
171: comment-column)))) ; except leave at least one space.
172:
173: (defun electric-c-brace (arg)
174: "Insert character and correct line's indentation."
175: (interactive "P")
176: (let (insertpos)
177: (if (and (not arg)
178: (eolp)
179: (or (save-excursion
180: (skip-chars-backward " \t")
181: (bolp))
182: (if c-auto-newline (progn (c-indent-line) (newline) t) nil)))
183: (progn
184: (insert last-command-char)
185: (c-indent-line)
186: (if c-auto-newline
187: (progn
188: (newline)
189: ;; (newline) may have done auto-fill
190: (setq insertpos (- (point) 2))
191: (c-indent-line)))
192: (save-excursion
193: (if insertpos (goto-char (1+ insertpos)))
194: (delete-char -1))))
195: (if insertpos
196: (save-excursion
197: (goto-char insertpos)
198: (self-insert-command (prefix-numeric-value arg)))
199: (self-insert-command (prefix-numeric-value arg)))))
200:
201: (defun electric-c-semi (arg)
202: "Insert character and correct line's indentation."
203: (interactive "P")
204: (if c-auto-newline
205: (electric-c-terminator arg)
206: (self-insert-command (prefix-numeric-value arg))))
207:
208: (defun electric-c-terminator (arg)
209: "Insert character and correct line's indentation."
210: (interactive "P")
211: (let (insertpos (end (point)))
212: (if (and (not arg) (eolp)
213: (not (save-excursion
214: (beginning-of-line)
215: (skip-chars-forward " \t")
216: (or (= (following-char) ?#)
217: ;; Colon is special only after a label, or case ....
218: ;; So quickly rule out most other uses of colon
219: ;; and do no indentation for them.
220: (and (eq last-command-char ?:)
221: (not (looking-at "case[ \t]"))
222: (save-excursion
223: (forward-word 1)
224: (skip-chars-forward " \t")
225: (< (point) end)))
226: (progn
227: (beginning-of-defun)
228: (let ((pps (parse-partial-sexp (point) end)))
229: (or (nth 3 pps) (nth 4 pps) (nth 5 pps))))))))
230: (progn
231: (insert last-command-char)
232: (c-indent-line)
233: (and c-auto-newline
234: (not (c-inside-parens-p))
235: (progn
236: (newline)
237: (setq insertpos (- (point) 2))
238: (c-indent-line)))
239: (save-excursion
240: (if insertpos (goto-char (1+ insertpos)))
241: (delete-char -1))))
242: (if insertpos
243: (save-excursion
244: (goto-char insertpos)
245: (self-insert-command (prefix-numeric-value arg)))
246: (self-insert-command (prefix-numeric-value arg)))))
247:
248: (defun c-inside-parens-p ()
249: (condition-case ()
250: (save-excursion
251: (save-restriction
252: (narrow-to-region (point)
253: (progn (beginning-of-defun) (point)))
254: (goto-char (point-max))
255: (= (char-after (or (scan-lists (point) -1 1) (point-min))) ?\()))
256: (error nil)))
257:
258: (defun c-indent-command (&optional whole-exp)
259: "Indent current line as C code, or in some cases insert a tab character.
260: If c-tab-always-indent is non-nil (the default), always indent current line.
261: Otherwise, indent the current line only if point is at the left margin
262: or in the line's indentation; otherwise insert a tab.
263:
264: A numeric argument, regardless of its value,
265: means indent rigidly all the lines of the expression starting after point
266: so that this line becomes properly indented.
267: The relative indentation among the lines of the expression are preserved."
268: (interactive "P")
269: (if whole-exp
270: ;; If arg, always indent this line as C
271: ;; and shift remaining lines of expression the same amount.
272: (let ((shift-amt (c-indent-line))
273: beg end)
274: (save-excursion
275: (if c-tab-always-indent
276: (beginning-of-line))
277: (setq beg (point))
278: (forward-sexp 1)
279: (setq end (point))
280: (goto-char beg)
281: (forward-line 1)
282: (setq beg (point)))
283: (if (> end beg)
284: (indent-code-rigidly beg end shift-amt "#")))
285: (if (and (not c-tab-always-indent)
286: (save-excursion
287: (skip-chars-backward " \t")
288: (not (bolp))))
289: (insert-tab)
290: (c-indent-line))))
291:
292: (defun c-indent-line ()
293: "Indent current line as C code.
294: Return the amount the indentation changed by."
295: (let ((indent (calculate-c-indent nil))
296: beg shift-amt
297: (case-fold-search nil)
298: (pos (- (point-max) (point))))
299: (beginning-of-line)
300: (setq beg (point))
301: (cond ((eq indent nil)
302: (setq indent (current-indentation)))
303: ((eq indent t)
304: (setq indent (calculate-c-indent-within-comment)))
305: ((looking-at "[ \t]*#")
306: (setq indent 0))
307: (t
308: (skip-chars-forward " \t")
309: (if (listp indent) (setq indent (car indent)))
310: (cond ((or (looking-at "case[ \t]")
311: (and (looking-at "[A-Za-z]")
312: (save-excursion
313: (forward-sexp 1)
314: (looking-at ":"))))
315: (setq indent (max 1 (+ indent c-label-offset))))
316: ((and (looking-at "else\\b")
317: (not (looking-at "else\\s_")))
318: (setq indent (save-excursion
319: (c-backward-to-start-of-if)
320: (current-indentation))))
321: ((= (following-char) ?})
322: (setq indent (- indent c-indent-level)))
323: ((= (following-char) ?{)
324: (setq indent (+ indent c-brace-offset))))))
325: (skip-chars-forward " \t")
326: (setq shift-amt (- indent (current-column)))
327: (if (zerop shift-amt)
328: (if (> (- (point-max) pos) (point))
329: (goto-char (- (point-max) pos)))
330: (delete-region beg (point))
331: (indent-to indent)
332: ;; If initial point was within line's indentation,
333: ;; position after the indentation. Else stay at same point in text.
334: (if (> (- (point-max) pos) (point))
335: (goto-char (- (point-max) pos))))
336: shift-amt))
337:
338: (defun calculate-c-indent (&optional parse-start)
339: "Return appropriate indentation for current line as C code.
340: In usual case returns an integer: the column to indent to.
341: Returns nil if line starts inside a string, t if in a comment."
342: (save-excursion
343: (beginning-of-line)
344: (let ((indent-point (point))
345: (case-fold-search nil)
346: state
347: containing-sexp)
348: (if parse-start
349: (goto-char parse-start)
350: (beginning-of-defun))
351: (while (< (point) indent-point)
352: (setq parse-start (point))
353: (setq state (parse-partial-sexp (point) indent-point 0))
354: (setq containing-sexp (car (cdr state))))
355: (cond ((or (nth 3 state) (nth 4 state))
356: ;; return nil or t if should not change this line
357: (nth 4 state))
358: ((null containing-sexp)
359: ;; Line is at top level. May be data or function definition,
360: ;; or may be function argument declaration.
361: ;; Indent like the previous top level line
362: ;; unless that ends in a closeparen without semicolon,
363: ;; in which case this line is the first argument decl.
364: (goto-char indent-point)
365: (skip-chars-forward " \t")
366: (if (= (following-char) ?{)
367: 0 ; Unless it starts a function body
368: (c-backward-to-noncomment (or parse-start (point-min)))
369: ;; Look at previous line that's at column 0
370: ;; to determine whether we are in top-level decls
371: ;; or function's arg decls. Set basic-indent accordinglu.
372: (let ((basic-indent
373: (save-excursion
374: (re-search-backward "^[^ \^L\t\n#]" nil 'move)
375: (if (and (looking-at "\\sw\\|\\s_")
376: (looking-at "[^\"\n=(]*(")
377: (progn
378: (goto-char (1- (match-end 0)))
379: (forward-sexp 1)
380: (and (< (point) indent-point)
381: (not (memq (following-char)
382: '(?\, ?\;))))))
383: c-argdecl-indent 0))))
384: ;; Now add a little if this is a continuation line.
385: (+ basic-indent (if (or (bobp)
386: (memq (preceding-char) '(?\) ?\; ?\})))
387: 0 c-continued-statement-offset)))))
388: ((/= (char-after containing-sexp) ?{)
389: ;; line is expression, not statement:
390: ;; indent to just after the surrounding open.
391: (goto-char (1+ containing-sexp))
392: (current-column))
393: (t
394: ;; Statement level. Is it a continuation or a new statement?
395: ;; Find previous non-comment character.
396: (goto-char indent-point)
397: (c-backward-to-noncomment containing-sexp)
398: ;; Back up over label lines, since they don't
399: ;; affect whether our line is a continuation.
400: (while (or (eq (preceding-char) ?\,)
401: (and (eq (preceding-char) ?:)
402: (or (eq (char-after (- (point) 2)) ?\')
403: (memq (char-syntax (char-after (- (point) 2)))
404: '(?w ?_)))))
405: (if (eq (preceding-char) ?\,)
406: (c-backward-to-start-of-continued-exp containing-sexp))
407: (beginning-of-line)
408: (c-backward-to-noncomment containing-sexp))
409: ;; Now we get the answer.
410: (if (not (memq (preceding-char) '(nil ?\, ?\; ?\} ?\{)))
411: ;; This line is continuation of preceding line's statement;
412: ;; indent c-continued-statement-offset more than the
413: ;; previous line of the statement.
414: (progn
415: (c-backward-to-start-of-continued-exp containing-sexp)
416: (+ c-continued-statement-offset (current-column)
417: (if (save-excursion (goto-char indent-point)
418: (skip-chars-forward " \t")
419: (eq (following-char) ?{))
420: c-continued-brace-offset 0)))
421: ;; This line starts a new statement.
422: ;; Position following last unclosed open.
423: (goto-char containing-sexp)
424: ;; Is line first statement after an open-brace?
425: (or
426: ;; If no, find that first statement and indent like it.
427: (save-excursion
428: (forward-char 1)
429: (let ((colon-line-end 0))
430: (while (progn (skip-chars-forward " \t\n")
431: (looking-at "#\\|/\\*\\|case[ \t\n].*:\\|[a-zA-Z0-9_$]*:"))
432: ;; Skip over comments and labels following openbrace.
433: (cond ((= (following-char) ?\#)
434: (forward-line 1))
435: ((= (following-char) ?\/)
436: (forward-char 2)
437: (search-forward "*/" nil 'move))
438: ;; case or label:
439: (t
440: (save-excursion (end-of-line)
441: (setq colon-line-end (point)))
442: (search-forward ":"))))
443: ;; The first following code counts
444: ;; if it is before the line we want to indent.
445: (and (< (point) indent-point)
446: (-
447: (if (> colon-line-end (point))
448: (- (current-indentation) c-label-offset)
449: (current-column))
450: (if (= (following-char) ?\{) c-brace-offset 0)))))
451: ;; If no previous statement,
452: ;; indent it relative to line brace is on.
453: ;; For open brace in column zero, don't let statement
454: ;; start there too. If c-indent-level is zero,
455: ;; use c-brace-offset + c-continued-statement-offset instead.
456: ;; For open-braces not the first thing in a line,
457: ;; add in c-brace-imaginary-offset.
458: (+ (if (and (bolp) (zerop c-indent-level))
459: (+ c-brace-offset c-continued-statement-offset)
460: c-indent-level)
461: ;; Move back over whitespace before the openbrace.
462: ;; If openbrace is not first nonwhite thing on the line,
463: ;; add the c-brace-imaginary-offset.
464: (progn (skip-chars-backward " \t")
465: (if (bolp) 0 c-brace-imaginary-offset))
466: ;; If the openbrace is preceded by a parenthesized exp,
467: ;; move to the beginning of that;
468: ;; possibly a different line
469: (progn
470: (if (eq (preceding-char) ?\))
471: (forward-sexp -1))
472: ;; Get initial indentation of the line we are on.
473: (current-indentation))))))))))
474:
475: (defun calculate-c-indent-within-comment ()
476: "Return the indentation amount for line, assuming that
477: the current line is to be regarded as part of a block comment."
478: (let (end star-start)
479: (save-excursion
480: (beginning-of-line)
481: (skip-chars-forward " \t")
482: (setq star-start (= (following-char) ?\*))
483: (skip-chars-backward " \t\n")
484: (setq end (point))
485: (beginning-of-line)
486: (skip-chars-forward " \t")
487: (and (re-search-forward "/\\*[ \t]*" end t)
488: star-start
489: (goto-char (1+ (match-beginning 0))))
490: (current-column))))
491:
492:
493: (defun c-backward-to-noncomment (lim)
494: (let (opoint stop)
495: (while (not stop)
496: (skip-chars-backward " \t\n\f" lim)
497: (setq opoint (point))
498: (if (and (>= (point) (+ 2 lim))
499: (save-excursion
500: (forward-char -2)
501: (looking-at "\\*/")))
502: (search-backward "/*" lim 'move)
503: (setq stop (or (<= (point) lim)
504: (save-excursion
505: (beginning-of-line)
506: (skip-chars-forward " \t")
507: (not (looking-at "#")))))
508: (or stop (beginning-of-line))))))
509:
510: (defun c-backward-to-start-of-continued-exp (lim)
511: (if (= (preceding-char) ?\))
512: (forward-sexp -1))
513: (beginning-of-line)
514: (if (<= (point) lim)
515: (goto-char (1+ lim)))
516: (skip-chars-forward " \t"))
517:
518: (defun c-backward-to-start-of-if (&optional limit)
519: "Move to the start of the last ``unbalanced'' if."
520: (or limit (setq limit (save-excursion (beginning-of-defun) (point))))
521: (let ((if-level 1)
522: (case-fold-search nil))
523: (while (not (zerop if-level))
524: (backward-sexp 1)
525: (cond ((looking-at "else\\b")
526: (setq if-level (1+ if-level)))
527: ((looking-at "if\\b")
528: (setq if-level (1- if-level)))
529: ((< (point) limit)
530: (setq if-level 0)
531: (goto-char limit))))))
532:
533:
534: (defun mark-c-function ()
535: "Put mark at end of C function, point at beginning."
536: (interactive)
537: (push-mark (point))
538: (end-of-defun)
539: (push-mark (point))
540: (beginning-of-defun)
541: (backward-paragraph))
542:
543: (defun indent-c-exp ()
544: "Indent each line of the C grouping following point."
545: (interactive)
546: (let ((indent-stack (list nil))
547: (contain-stack (list (point)))
548: (case-fold-search nil)
549: restart outer-loop-done inner-loop-done state ostate
550: this-indent last-sexp
551: at-else at-brace
552: (opoint (point))
553: (next-depth 0))
554: (save-excursion
555: (forward-sexp 1))
556: (save-excursion
557: (setq outer-loop-done nil)
558: (while (and (not (eobp)) (not outer-loop-done))
559: (setq last-depth next-depth)
560: ;; Compute how depth changes over this line
561: ;; plus enough other lines to get to one that
562: ;; does not end inside a comment or string.
563: ;; Meanwhile, do appropriate indentation on comment lines.
564: (setq inner-loop-done nil)
565: (while (and (not inner-loop-done)
566: (not (and (eobp) (setq outer-loop-done t))))
567: (setq ostate state)
568: (setq state (parse-partial-sexp (point) (progn (end-of-line) (point))
569: nil nil state))
570: (setq next-depth (car state))
571: (if (and (car (cdr (cdr state)))
572: (>= (car (cdr (cdr state))) 0))
573: (setq last-sexp (car (cdr (cdr state)))))
574: (if (or (nth 4 ostate))
575: (c-indent-line))
576: (if (or (nth 3 state))
577: (forward-line 1)
578: (setq inner-loop-done t)))
579: (if (<= next-depth 0)
580: (setq outer-loop-done t))
581: (if outer-loop-done
582: nil
583: ;; If this line had ..))) (((.. in it, pop out of the levels
584: ;; that ended anywhere in this line, even if the final depth
585: ;; doesn't indicate that they ended.
586: (while (> last-depth (nth 6 state))
587: (setq indent-stack (cdr indent-stack)
588: contain-stack (cdr contain-stack)
589: last-depth (1- last-depth)))
590: (if (/= last-depth next-depth)
591: (setq last-sexp nil))
592: ;; Add levels for any parens that were started in this line.
593: (while (< last-depth next-depth)
594: (setq indent-stack (cons nil indent-stack)
595: contain-stack (cons nil contain-stack)
596: last-depth (1+ last-depth)))
597: (if (null (car contain-stack))
598: (setcar contain-stack (or (car (cdr state))
599: (save-excursion (forward-sexp -1)
600: (point)))))
601: (forward-line 1)
602: (skip-chars-forward " \t")
603: (if (eolp)
604: nil
605: (if (and (car indent-stack)
606: (>= (car indent-stack) 0))
607: ;; Line is on an existing nesting level.
608: ;; Lines inside parens are handled specially.
609: (if (/= (char-after (car contain-stack)) ?{)
610: (setq this-indent (car indent-stack))
611: ;; Line is at statement level.
612: ;; Is it a new statement? Is it an else?
613: ;; Find last non-comment character before this line
614: (save-excursion
615: (setq at-else (looking-at "else\\W"))
616: (setq at-brace (= (following-char) ?{))
617: (c-backward-to-noncomment opoint)
618: (if (not (memq (preceding-char) '(nil ?\, ?\; ?} ?: ?{)))
619: ;; Preceding line did not end in comma or semi;
620: ;; indent this line c-continued-statement-offset
621: ;; more than previous.
622: (progn
623: (c-backward-to-start-of-continued-exp (car contain-stack))
624: (setq this-indent
625: (+ c-continued-statement-offset (current-column)
626: (if at-brace c-continued-brace-offset 0))))
627: ;; Preceding line ended in comma or semi;
628: ;; use the standard indent for this level.
629: (if at-else
630: (progn (c-backward-to-start-of-if opoint)
631: (setq this-indent (current-indentation)))
632: (setq this-indent (car indent-stack))))))
633: ;; Just started a new nesting level.
634: ;; Compute the standard indent for this level.
635: (let ((val (calculate-c-indent
636: (if (car indent-stack)
637: (- (car indent-stack))))))
638: (setcar indent-stack
639: (setq this-indent val))))
640: ;; Adjust line indentation according to its contents
641: (if (or (looking-at "case[ \t]")
642: (and (looking-at "[A-Za-z]")
643: (save-excursion
644: (forward-sexp 1)
645: (looking-at ":"))))
646: (setq this-indent (max 1 (+ this-indent c-label-offset))))
647: (if (= (following-char) ?})
648: (setq this-indent (- this-indent c-indent-level)))
649: (if (= (following-char) ?{)
650: (setq this-indent (+ this-indent c-brace-offset)))
651: ;; Put chosen indentation into effect.
652: (or (= (current-column) this-indent)
653: (= (following-char) ?\#)
654: (progn
655: (delete-region (point) (progn (beginning-of-line) (point)))
656: (indent-to this-indent)))
657: ;; Indent any comment following the text.
658: (or (looking-at comment-start-skip)
659: (if (re-search-forward comment-start-skip (save-excursion (end-of-line) (point)) t)
660: (progn (indent-for-comment) (beginning-of-line)))))))))
661: ; (message "Indenting C expression...done")
662: )
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.