![[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] / 43BSD / contrib / emacs / lisp|
Return to c-mode.el CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / lisp |
1.1 root 1: ;; C code editing commands for Emacs
2: ;; Copyright (C) 1985 Richard M. Stallman.
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-syntax-table nil
23: "Syntax table in use in C-mode buffers.")
24: (defvar c-mode-abbrev-table nil
25: "Abbrev table in use in C-mode buffers.")
26:
27: (defvar c-mode-map (make-sparse-keymap)
28: "Keymap used in C mode.")
29:
30: (define-key c-mode-map "\C-j" 'reindent-then-newline-and-indent)
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-line)
39:
40: (defconst c-indent-level 2
41: "*Indentation of C statements with respect to containing block.")
42: (defconst c-brace-imaginary-offset 0
43: "*Imagined indentation of a C open brace that actually follows a statement.")
44: (defconst c-brace-offset 0
45: "*Extra indentation for braces, compared with other text in same context.")
46: (defconst c-argdecl-indent 5
47: "*Indentation level of declarations of C function arguments.")
48: (defconst c-label-offset -2
49: "*Offset of C label lines and case statements relative to usual indentation.")
50: (defconst c-continued-statement-offset 2
51: "*Extra indent for lines not starting new statements.")
52:
53: (defconst c-auto-newline nil
54: "*Non-nil means automatically newline before and after braces,
55: and after colons and semicolons, inserted in C code.")
56:
57: (defun c-mode ()
58: "Major mode for editing C code.
59: Expression and list commands understand all C brackets.
60: Tab indents for C code.
61: Comments are delimited with /* ... */.
62: Paragraphs are separated by blank lines only.
63: Delete converts tabs to spaces as it moves back.
64: \\{c-mode-map}
65: Variables controlling indentation style:
66: c-auto-newline
67: Non-nil means automatically newline before and after braces,
68: and after colons and semicolons, inserted in C code.
69: c-indent-level
70: Indentation of C statements within surrounding block.
71: The surrounding block's indentation is the indentation
72: of the line on which the open-brace appears.
73: c-continued-statement-offset
74: Extra indentation given to a substatement, such as the
75: then-clause of an if or body of a while.
76: c-brace-offset
77: Extra indentation for line if it starts with an open brace.
78: c-brace-imaginary-offset
79: An open brace following other text is treated as if it were
80: this far to the right of the start of its line.
81: c-argdecl-indent
82: Indentation level of declarations of C function arguments.
83: c-label-offset
84: Extra indentation for line that is a label, or case or default.
85:
86: Turning on C mode calls the value of the variable c-mode-hook with no args,
87: if that value is non-nil."
88: (interactive)
89: (kill-all-local-variables)
90: (use-local-map c-mode-map)
91: (setq major-mode 'c-mode)
92: (setq mode-name "C")
93: (define-abbrev-table 'c-mode-abbrev-table ())
94: (setq local-abbrev-table c-mode-abbrev-table)
95: (if (not c-mode-syntax-table)
96: (let ((i 0))
97: (setq c-mode-syntax-table (make-syntax-table))
98: (set-syntax-table c-mode-syntax-table)
99: (modify-syntax-entry ?\\ "\\")
100: (modify-syntax-entry ?/ ". 14")
101: (modify-syntax-entry ?* ". 23")
102: (modify-syntax-entry ?+ ".")
103: (modify-syntax-entry ?- ".")
104: (modify-syntax-entry ?= ".")
105: (modify-syntax-entry ?% ".")
106: (modify-syntax-entry ?< ".")
107: (modify-syntax-entry ?> ".")
108: (modify-syntax-entry ?\' "\""))
109: (set-syntax-table c-mode-syntax-table))
110: (make-local-variable 'paragraph-start)
111: (setq paragraph-start (concat "^$\\|" page-delimiter))
112: (make-local-variable 'paragraph-separate)
113: (setq paragraph-separate paragraph-start)
114: (make-local-variable 'indent-line-function)
115: (setq indent-line-function 'c-indent-line)
116: (make-local-variable 'require-final-newline)
117: (setq require-final-newline t)
118: (make-local-variable 'comment-start)
119: (setq comment-start "/* ")
120: (make-local-variable 'comment-end)
121: (setq comment-end " */")
122: (make-local-variable 'comment-column)
123: (setq comment-column 32)
124: (make-local-variable 'comment-start-skip)
125: (setq comment-start-skip "/\\*+ *")
126: (make-local-variable 'comment-indent-hook)
127: (setq comment-indent-hook 'c-comment-indent)
128: (make-local-variable 'parse-sexp-ignore-comments)
129: (setq parse-sexp-ignore-comments t)
130: (run-hooks 'c-mode-hook))
131:
132: ;; This is used by indent-for-comment
133: ;; to decide how much to indent a comment in C code
134: ;; based on its context.
135: (defun c-comment-indent ()
136: (if (looking-at "^/\\*")
137: 0 ;Existing comment at bol stays there.
138: (save-excursion
139: (skip-chars-backward " \t")
140: (max (1+ (current-column)) ;Else indent at comment column
141: comment-column)))) ; except leave at least one space.
142:
143: (defun electric-c-brace (arg)
144: "Insert character and correct line's indentation."
145: (interactive "P")
146: (let (insertpos)
147: (if (and (not arg)
148: (eolp)
149: (or (save-excursion
150: (skip-chars-backward " \t")
151: (bolp))
152: (if c-auto-newline (progn (c-indent-line) (newline) t) nil)))
153: (progn
154: (insert last-command-char)
155: (c-indent-line nil)
156: (if c-auto-newline
157: (progn
158: (setq insertpos (1- (point)))
159: (newline)
160: (c-indent-line nil)))
161: (save-excursion
162: (if insertpos (goto-char (1+ insertpos)))
163: (delete-char -1))))
164: (if insertpos
165: (save-excursion
166: (goto-char insertpos)
167: (self-insert-command (prefix-numeric-value arg)))
168: (self-insert-command (prefix-numeric-value arg)))))
169:
170: (defun electric-c-semi (arg)
171: "Insert character and correct line's indentation."
172: (interactive "P")
173: (if c-auto-newline
174: (electric-c-terminator arg)
175: (self-insert-command (prefix-numeric-value arg))))
176:
177: (defun electric-c-terminator (arg)
178: "Insert character and correct line's indentation."
179: (interactive "P")
180: (let (insertpos (end (point)))
181: (if (and (not arg) (eolp)
182: (not (save-excursion
183: (beginning-of-line)
184: (skip-chars-forward " \t")
185: (or (= (following-char) ?#)
186: (let ((pps (parse-partial-sexp (point) end)))
187: (or (nth 3 pps) (nth 4 pps) (nth 5 pps)))))))
188: (progn
189: (insert last-command-char)
190: (c-indent-line nil)
191: (and c-auto-newline
192: (not (c-inside-parens-p))
193: (progn
194: (setq insertpos (1- (point)))
195: (newline)
196: (c-indent-line nil)))
197: (save-excursion
198: (if insertpos (goto-char (1+ insertpos)))
199: (delete-char -1))))
200: (if insertpos
201: (save-excursion
202: (goto-char insertpos)
203: (self-insert-command (prefix-numeric-value arg)))
204: (self-insert-command (prefix-numeric-value arg)))))
205:
206: (defun c-inside-parens-p ()
207: (condition-case ()
208: (save-excursion
209: (save-restriction
210: (narrow-to-region (point)
211: (progn (beginning-of-defun) (point)))
212: (goto-char (point-max))
213: (= (char-after (or (scan-lists (point) -1 1) (point-min))) ?\()))
214: (error nil)))
215:
216: (defun c-indent-line (&optional whole-exp)
217: "Indent current line as C code.
218: Argument means shift any additional lines of grouping
219: rigidly with thls line."
220: (interactive "P")
221: (let ((indent (calculate-c-indent nil))
222: beg end shift-amt
223: (case-fold-search nil)
224: (pos (- (point-max) (point))))
225: (beginning-of-line)
226: (setq beg (point))
227: (cond ((eq indent nil)
228: (setq indent (current-indentation)))
229: ((eq indent t)
230: (setq indent (calculate-c-indent-within-comment)))
231: ((looking-at "[ \t]*#")
232: (setq indent 0))
233: (t
234: (skip-chars-forward " \t")
235: (if (listp indent) (setq indent (car indent)))
236: (cond ((or (looking-at "case\\b")
237: (and (looking-at "[A-Za-z]")
238: (save-excursion
239: (forward-sexp 1)
240: (looking-at ":"))))
241: (setq indent (max 1 (+ indent c-label-offset))))
242: ((looking-at "else\\b")
243: (setq indent (save-excursion
244: (c-backward-to-start-of-if)
245: (current-indentation))))
246: ((= (following-char) ?})
247: (setq indent (- indent c-indent-level)))
248: ((= (following-char) ?{)
249: (setq indent (+ indent c-brace-offset))))))
250: (skip-chars-forward " \t")
251: (setq shift-amt (- indent (current-column)))
252: (if (zerop shift-amt)
253: (if (> (- (point-max) pos) (point))
254: (goto-char (- (point-max) pos)))
255: (delete-region beg (point))
256: (indent-to indent)
257: ;; If initial point was within line's indentation,
258: ;; position after the indentation. Else stay at same point in text.
259: (if (> (- (point-max) pos) (point))
260: (goto-char (- (point-max) pos)))
261: ;; If desired, shift remaining lines of expression the same amount.
262: (and whole-exp
263: (save-excursion
264: (goto-char beg)
265: (forward-sexp 1)
266: (setq end (point))
267: (goto-char beg)
268: (forward-line 1)
269: (setq beg (point))
270: (> end beg))
271: (indent-code-rigidly beg end shift-amt "#")))))
272:
273: (defun calculate-c-indent (&optional parse-start)
274: "Return appropriate indentation for current line as C code.
275: In usual case returns an integer: the column to indent to.
276: Returns nil if line starts inside a string, t if in a comment."
277: (save-excursion
278: (beginning-of-line)
279: (let ((indent-point (point))
280: (case-fold-search nil)
281: state
282: containing-sexp)
283: (if parse-start
284: (goto-char parse-start)
285: (beginning-of-defun))
286: (while (< (point) indent-point)
287: (setq parse-start (point))
288: (setq state (parse-partial-sexp (point) indent-point 0))
289: (setq containing-sexp (car (cdr state))))
290: (cond ((or (nth 3 state) (nth 4 state))
291: ;; return nil or t if should not change this line
292: (nth 4 state))
293: ((null containing-sexp)
294: ;; Line is at top level. May be data or function definition,
295: ;; or may be function argument declaration.
296: ;; Indent like the previous top level line
297: ;; unless that ends in a closeparen without semicolon,
298: ;; in which case this line is the first argument decl.
299: (goto-char indent-point)
300: (skip-chars-forward " \t")
301: (if (= (following-char) ?{)
302: 0 ; Unless it starts a function body
303: (c-backward-to-noncomment (or parse-start (point-min)))
304: (if (= (preceding-char) ?\))
305: c-argdecl-indent
306: (current-indentation))))
307: ((/= (char-after containing-sexp) ?{)
308: ;; line is expression, not statement:
309: ;; indent to just after the surrounding open.
310: (goto-char (1+ containing-sexp))
311: (current-column))
312: (t
313: ;; Statement. Find previous non-comment character.
314: (goto-char indent-point)
315: (c-backward-to-noncomment containing-sexp)
316: (if (not (memq (preceding-char) '(nil ?\, ?\; ?} ?: ?\{)))
317: ;; This line is continuation of preceding line's statement;
318: ;; indent c-continued-statement-offset more than the
319: ;; previous line of the statement.
320: (progn
321: (c-backward-to-start-of-continued-exp containing-sexp)
322: (+ c-continued-statement-offset (current-column)))
323: ;; This line starts a new statement.
324: ;; Position following last unclosed open.
325: (goto-char containing-sexp)
326: ;; Is line first statement after an open-brace?
327: (or
328: ;; If no, find that first statement and indent like it.
329: (save-excursion
330: (forward-char 1)
331: (while (progn (skip-chars-forward " \t\n")
332: (looking-at "#\\|/\\*\\|case[ \t\n]\\|[a-zA-Z0-9_$]*:"))
333: ;; Skip over comments and labels following openbrace.
334: (if (= (following-char) ?\#)
335: (forward-line 1)
336: (if (looking-at "/\\*")
337: (search-forward "*/" nil 'move)
338: (search-forward ":"))))
339: ;; The first following code counts
340: ;; if it is before the line we want to indent.
341: (and (< (point) indent-point)
342: (current-column)))
343: ;; If no previous statement,
344: ;; indent it relative to line brace is on.
345: ;; For open brace in column zero, don't let statement
346: ;; start there too. If c-indent-offset is zero,
347: ;; use c-brace-offset + c-continued-statement-offset instead.
348: ;; For open-braces not the first thing in a line,
349: ;; add in c-brace-imaginary-offset.
350: (+ (if (and (bolp) (zerop c-indent-level))
351: (+ c-brace-offset c-continued-statement-offset)
352: c-indent-level)
353: (if (save-excursion (skip-chars-backward " \t")
354: (bolp))
355: 0 c-brace-imaginary-offset)
356: (current-indentation)))))))))
357:
358: (defun calculate-c-indent-within-comment ()
359: "Return the indentation amount for line, assuming that
360: the current line is to be regarded as part of a block comment."
361: (let (end star-start)
362: (save-excursion
363: (beginning-of-line)
364: (skip-chars-forward " \t")
365: (setq star-start (= (following-char) ?\*))
366: (skip-chars-backward " \t\n")
367: (setq end (point))
368: (beginning-of-line)
369: (skip-chars-forward " \t")
370: (and (re-search-forward "/\\*[ \t]*" end t)
371: star-start
372: (goto-char (1+ (match-beginning 0))))
373: (current-column))))
374:
375:
376: (defun c-backward-to-noncomment (lim)
377: (let (opoint stop)
378: (while (not stop)
379: (skip-chars-backward " \t\n" lim)
380: (setq opoint (point))
381: (if (and (>= (point) (+ 2 lim))
382: (save-excursion
383: (forward-char -2)
384: (looking-at "\\*/")))
385: (search-backward "/*" lim 'move)
386: (beginning-of-line)
387: (skip-chars-forward " \t")
388: (if (looking-at "#")
389: (setq stop (<= (point) lim))
390: (setq stop t)
391: (goto-char opoint))))))
392:
393: (defun c-backward-to-start-of-continued-exp (lim)
394: (if (= (preceding-char) ?\))
395: (forward-sexp -1))
396: (beginning-of-line)
397: (if (<= (point) lim)
398: (goto-char (1+ lim)))
399: (skip-chars-forward " \t"))
400:
401: (defun c-backward-to-start-of-if (&optional limit)
402: "Move to the start of the last ``unbalanced'' if."
403: (or limit (setq limit (save-excursion (beginning-of-defun) (point))))
404: (let ((if-level 1)
405: (case-fold-search nil))
406: (while (not (zerop if-level))
407: (backward-sexp 1)
408: (cond ((looking-at "else\\b")
409: (setq if-level (1+ if-level)))
410: ((looking-at "if\\b")
411: (setq if-level (1- if-level)))
412: ((< (point) limit)
413: (setq if-level 0)
414: (goto-char limit))))))
415:
416:
417: (defun mark-c-function ()
418: "Put mark at end of C function, point at beginning."
419: (interactive)
420: (push-mark (point))
421: (end-of-defun)
422: (push-mark (point))
423: (beginning-of-defun)
424: (backward-paragraph))
425:
426: (defun indent-c-exp ()
427: "Indent each line of the C grouping following point."
428: (interactive)
429: (let ((indent-stack (list nil))
430: (contain-stack (list (point)))
431: (case-fold-search nil)
432: restart outer-loop-done inner-loop-done state ostate
433: this-indent last-sexp
434: at-else
435: (opoint (point))
436: (next-depth 0))
437: (save-excursion
438: (forward-sexp 1))
439: (save-excursion
440: (setq outer-loop-done nil)
441: (while (and (not (eobp)) (not outer-loop-done))
442: (setq last-depth next-depth)
443: ;; Compute how depth changes over this line
444: ;; plus enough other lines to get to one that
445: ;; does not end inside a comment or string.
446: ;; Meanwhile, do appropriate indentation on comment lines.
447: (setq innerloop-done nil)
448: (while (and (not innerloop-done)
449: (not (and (eobp) (setq outer-loop-done t))))
450: (setq ostate state)
451: (setq state (parse-partial-sexp (point) (progn (end-of-line) (point))
452: nil nil state))
453: (setq next-depth (car state))
454: (if (and (car (cdr (cdr state)))
455: (>= (car (cdr (cdr state))) 0))
456: (setq last-sexp (car (cdr (cdr state)))))
457: (if (or (nth 4 ostate))
458: (c-indent-line))
459: (if (or (nth 3 state))
460: (forward-line 1)
461: (setq innerloop-done t)))
462: (if (<= next-depth 0)
463: (setq outer-loop-done t))
464: (if outer-loop-done
465: nil
466: (if (/= last-depth next-depth)
467: (setq last-sexp nil))
468: (while (> last-depth next-depth)
469: (setq indent-stack (cdr indent-stack)
470: contain-stack (cdr contain-stack)
471: last-depth (1- last-depth)))
472: (while (< last-depth next-depth)
473: (setq indent-stack (cons nil indent-stack)
474: contain-stack (cons nil contain-stack)
475: last-depth (1+ last-depth)))
476: (if (null (car contain-stack))
477: (setcar contain-stack (or (car (cdr state))
478: (save-excursion (forward-sexp -1)
479: (point)))))
480: (forward-line 1)
481: (skip-chars-forward " \t")
482: (if (eolp)
483: nil
484: (if (and (car indent-stack)
485: (>= (car indent-stack) 0))
486: ;; Line is on an existing nesting level.
487: ;; Lines inside parens are handled specially.
488: (if (/= (char-after (car contain-stack)) ?{)
489: (setq this-indent (car indent-stack))
490: ;; Line is at statement level.
491: ;; Is it a new statement? Is it an else?
492: ;; Find last non-comment character before this line
493: (save-excursion
494: (setq at-else (looking-at "else\\W"))
495: (c-backward-to-noncomment opoint)
496: (if (not (memq (preceding-char) '(nil ?\, ?\; ?} ?: ?{)))
497: ;; Preceding line did not end in comma or semi;
498: ;; indent this line c-continued-statement-offset
499: ;; more than previous.
500: (progn
501: (c-backward-to-start-of-continued-exp (car contain-stack))
502: (setq this-indent
503: (+ c-continued-statement-offset (current-column))))
504: ;; Preceding line ended in comma or semi;
505: ;; use the standard indent for this level.
506: (if at-else
507: (progn (c-backward-to-start-of-if opoint)
508: (setq this-indent (current-indentation)))
509: (setq this-indent (car indent-stack))))))
510: ;; Just started a new nesting level.
511: ;; Compute the standard indent for this level.
512: (let ((val (calculate-c-indent
513: (if (car indent-stack)
514: (- (car indent-stack))))))
515: (setcar indent-stack
516: (setq this-indent val))))
517: ;; Adjust line indentation according to its contents
518: (if (or (looking-at "case[ \t]")
519: (and (looking-at "[A-Za-z]")
520: (save-excursion
521: (forward-sexp 1)
522: (looking-at ":"))))
523: (setq this-indent (max 1 (+ this-indent c-label-offset))))
524: (if (= (following-char) ?})
525: (setq this-indent (- this-indent c-indent-level)))
526: (if (= (following-char) ?{)
527: (setq this-indent (+ this-indent c-brace-offset)))
528: ;; Put chosen indentation into effect.
529: (or (= (current-column) this-indent)
530: (= (following-char) ?\#)
531: (progn
532: (delete-region (point) (progn (beginning-of-line) (point)))
533: (indent-to this-indent)))
534: ;; Indent any comment following the text.
535: (or (looking-at comment-start-skip)
536: (if (re-search-forward comment-start-skip (save-excursion (end-of-line) (point)) t)
537: (progn (indent-for-comment) (beginning-of-line)))))))))
538: ; (message "Indenting C expression...done")
539: )
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.