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