|
165
|
1 ;;; cc-engine.el --- core syntax guessing engine for CC mode
|
|
|
2
|
|
|
3 ;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 ;; Authors: 1992-1997 Barry A. Warsaw
|
|
|
6 ;; 1987 Dave Detlefs and Stewart Clamen
|
|
|
7 ;; 1985 Richard M. Stallman
|
|
|
8 ;; Maintainer: cc-mode-help@python.org
|
|
|
9 ;; Created: 22-Apr-1997 (split from cc-mode.el)
|
|
|
10 ;; Version: 5.11
|
|
|
11 ;; Keywords: c languages oop
|
|
|
12
|
|
|
13 ;; This file is part of GNU Emacs.
|
|
|
14
|
|
|
15 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
|
16 ;; it under the terms of the GNU General Public License as published by
|
|
|
17 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
18 ;; any later version.
|
|
|
19
|
|
|
20 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
|
21 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
22 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
23 ;; GNU General Public License for more details.
|
|
|
24
|
|
|
25 ;; You should have received a copy of the GNU General Public License
|
|
|
26 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
|
27 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
28 ;; Boston, MA 02111-1307, USA.
|
|
|
29
|
|
|
30
|
|
|
31 ;; utilities
|
|
|
32 (defmacro c-add-syntax (symbol &optional relpos)
|
|
|
33 ;; a simple macro to append the syntax in symbol to the syntax list.
|
|
|
34 ;; try to increase performance by using this macro
|
|
|
35 (` (setq syntax (cons (cons (, symbol) (, relpos)) syntax))))
|
|
|
36
|
|
|
37 (defsubst c-auto-newline ()
|
|
|
38 ;; if auto-newline feature is turned on, insert a newline character
|
|
|
39 ;; and return t, otherwise return nil.
|
|
|
40 (and c-auto-newline
|
|
|
41 (not (c-in-literal))
|
|
|
42 (not (newline))))
|
|
|
43
|
|
|
44 (defsubst c-intersect-lists (list alist)
|
|
|
45 ;; return the element of ALIST that matches the first element found
|
|
|
46 ;; in LIST. Uses assq.
|
|
|
47 (let (match)
|
|
|
48 (while (and list
|
|
|
49 (not (setq match (assq (car list) alist))))
|
|
|
50 (setq list (cdr list)))
|
|
|
51 match))
|
|
|
52
|
|
|
53 (defsubst c-lookup-lists (list alist1 alist2)
|
|
|
54 ;; first, find the first entry from LIST that is present in ALIST1,
|
|
|
55 ;; then find the entry in ALIST2 for that entry.
|
|
|
56 (assq (car (c-intersect-lists list alist1)) alist2))
|
|
|
57
|
|
|
58
|
|
|
59 ;; WARNING: Be *exceptionally* careful about modifications to this
|
|
|
60 ;; function! Much of CC Mode depends on this Doing The Right Thing.
|
|
|
61 ;; If you break it you will be sorry.
|
|
|
62
|
|
|
63 (defun c-beginning-of-statement-1 (&optional lim)
|
|
|
64 ;; move to the start of the current statement, or the previous
|
|
|
65 ;; statement if already at the beginning of one.
|
|
|
66 (let ((firstp t)
|
|
|
67 (substmt-p t)
|
|
|
68 donep c-in-literal-cache
|
|
|
69 ;; KLUDGE ALERT: maybe-labelp is used to pass information
|
|
|
70 ;; between c-crosses-statement-barrier-p and
|
|
|
71 ;; c-beginning-of-statement-1. A better way should be
|
|
|
72 ;; implemented.
|
|
|
73 maybe-labelp saved
|
|
|
74 (last-begin (point)))
|
|
|
75 ;; first check for bare semicolon
|
|
|
76 (if (and (progn (c-backward-syntactic-ws lim)
|
|
|
77 (= (preceding-char) ?\;))
|
|
|
78 (c-safe (progn (forward-char -1)
|
|
|
79 (setq saved (point))
|
|
|
80 t))
|
|
|
81 (progn (c-backward-syntactic-ws lim)
|
|
|
82 (memq (preceding-char) '(?\; ?{ ?} ?:)))
|
|
|
83 )
|
|
|
84 (setq last-begin saved)
|
|
|
85 (goto-char last-begin)
|
|
|
86 (while (not donep)
|
|
|
87 ;; stop at beginning of buffer
|
|
|
88 (if (bobp) (setq donep t)
|
|
|
89 ;; go backwards one balanced expression, but be careful of
|
|
|
90 ;; unbalanced paren being reached
|
|
|
91 (if (not (c-safe (progn (backward-sexp 1) t)))
|
|
|
92 (progn
|
|
|
93 (if firstp
|
|
|
94 (backward-up-list 1)
|
|
|
95 (goto-char last-begin))
|
|
|
96 ;; skip over any unary operators, or other special
|
|
|
97 ;; characters appearing at front of identifier
|
|
|
98 (save-excursion
|
|
|
99 (c-backward-syntactic-ws lim)
|
|
|
100 (skip-chars-backward "-+!*&:.~ \t\n")
|
|
|
101 (if (= (preceding-char) ?\()
|
|
|
102 (setq last-begin (point))))
|
|
|
103 (goto-char last-begin)
|
|
|
104 (setq last-begin (point)
|
|
|
105 donep t)))
|
|
|
106
|
|
|
107 (setq maybe-labelp nil)
|
|
|
108 ;; see if we're in a literal. if not, then this bufpos may be
|
|
|
109 ;; a candidate for stopping
|
|
|
110 (cond
|
|
|
111 ;; CASE 0: did we hit the error condition above?
|
|
|
112 (donep)
|
|
|
113 ;; CASE 1: are we in a literal?
|
|
|
114 ((eq (c-in-literal lim) 'pound)
|
|
|
115 (beginning-of-line))
|
|
|
116 ;; CASE 2: some other kind of literal?
|
|
|
117 ((c-in-literal lim))
|
|
|
118 ;; CASE 3: are we looking at a conditional keyword?
|
|
|
119 ((or (looking-at c-conditional-key)
|
|
|
120 (and (= (following-char) ?\()
|
|
|
121 (save-excursion
|
|
|
122 (forward-sexp 1)
|
|
|
123 (c-forward-syntactic-ws)
|
|
|
124 (/= (following-char) ?\;))
|
|
|
125 (let ((here (point))
|
|
|
126 (foundp (progn
|
|
|
127 (c-backward-syntactic-ws lim)
|
|
|
128 (forward-word -1)
|
|
|
129 (and lim
|
|
|
130 (<= lim (point))
|
|
|
131 (not (c-in-literal lim))
|
|
|
132 (looking-at c-conditional-key)
|
|
|
133 ))))
|
|
|
134 ;; did we find a conditional?
|
|
|
135 (if (not foundp)
|
|
|
136 (goto-char here))
|
|
|
137 foundp)))
|
|
|
138 ;; are we in the middle of an else-if clause?
|
|
|
139 (if (save-excursion
|
|
|
140 (and (not substmt-p)
|
|
|
141 (c-safe (progn (forward-sexp -1) t))
|
|
|
142 (looking-at "\\<else\\>[ \t\n]+\\<if\\>")
|
|
|
143 (not (c-in-literal lim))))
|
|
|
144 (progn
|
|
|
145 (forward-sexp -1)
|
|
|
146 (c-backward-to-start-of-if lim)))
|
|
|
147 ;; are we sitting at an else clause, that we are not a
|
|
|
148 ;; substatement of?
|
|
|
149 (if (and (not substmt-p)
|
|
|
150 (looking-at "\\<else\\>[^_]"))
|
|
|
151 (c-backward-to-start-of-if lim))
|
|
|
152 ;; are we sitting at the while of a do-while?
|
|
|
153 (if (and (looking-at "\\<while\\>[^_]")
|
|
|
154 (c-backward-to-start-of-do lim))
|
|
|
155 (setq substmt-p nil))
|
|
|
156 (setq last-begin (point)
|
|
|
157 donep substmt-p))
|
|
|
158 ;; CASE 4: are we looking at a label?
|
|
|
159 ((looking-at c-label-key))
|
|
|
160 ;; CASE 5: is this the first time we're checking?
|
|
|
161 (firstp (setq firstp nil
|
|
|
162 substmt-p (not (c-crosses-statement-barrier-p
|
|
|
163 (point) last-begin))
|
|
|
164 last-begin (point)))
|
|
|
165 ;; CASE 6: have we crossed a statement barrier?
|
|
|
166 ((c-crosses-statement-barrier-p (point) last-begin)
|
|
|
167 (setq donep t))
|
|
|
168 ;; CASE 7: ignore labels
|
|
|
169 ((and maybe-labelp
|
|
|
170 (or (and c-access-key (looking-at c-access-key))
|
|
|
171 ;; with switch labels, we have to go back further
|
|
|
172 ;; to try to pick up the case or default
|
|
|
173 ;; keyword. Potential bogosity alert: we assume
|
|
|
174 ;; `case' or `default' is first thing on line
|
|
|
175 (let ((here (point)))
|
|
|
176 (beginning-of-line)
|
|
|
177 (c-forward-syntactic-ws)
|
|
|
178 (if (looking-at c-switch-label-key)
|
|
|
179 t
|
|
|
180 (goto-char here)
|
|
|
181 nil))
|
|
|
182 (looking-at c-label-key))))
|
|
|
183 ;; CASE 8: ObjC or Java method def
|
|
|
184 ((and c-method-key
|
|
|
185 (setq last-begin (c-in-method-def-p)))
|
|
|
186 (setq donep t))
|
|
|
187 ;; CASE 9: nothing special
|
|
|
188 (t (setq last-begin (point)))
|
|
|
189 ))))
|
|
|
190 (goto-char last-begin)
|
|
|
191 ;; we always do want to skip over non-whitespace modifier
|
|
|
192 ;; characters that didn't get skipped above
|
|
|
193 (skip-chars-backward "-+!*&:.~" (c-point 'boi))))
|
|
|
194
|
|
|
195 (defun c-end-of-statement-1 ()
|
|
|
196 (condition-case ()
|
|
|
197 (progn
|
|
|
198 (while (and (not (eobp))
|
|
|
199 (let ((beg (point)))
|
|
|
200 (forward-sexp 1)
|
|
|
201 (let ((end (point)))
|
|
|
202 (save-excursion
|
|
|
203 (goto-char beg)
|
|
|
204 (not (re-search-forward "[;{}]" end t)))))))
|
|
|
205 (re-search-backward "[;}]")
|
|
|
206 (forward-char 1))
|
|
|
207 (error
|
|
|
208 (let ((beg (point)))
|
|
|
209 (backward-up-list -1)
|
|
|
210 (let ((end (point)))
|
|
|
211 (goto-char beg)
|
|
|
212 (search-forward ";" end 'move))))))
|
|
|
213
|
|
|
214
|
|
|
215
|
|
|
216 (defun c-crosses-statement-barrier-p (from to)
|
|
|
217 ;; Does buffer positions FROM to TO cross a C statement boundary?
|
|
|
218 (let ((here (point))
|
|
|
219 (lim from)
|
|
|
220 crossedp)
|
|
|
221 (condition-case ()
|
|
|
222 (progn
|
|
|
223 (goto-char from)
|
|
|
224 (while (and (not crossedp)
|
|
|
225 (< (point) to))
|
|
|
226 (skip-chars-forward "^;{}:" to)
|
|
|
227 (if (not (c-in-literal lim))
|
|
|
228 (progn
|
|
|
229 (if (memq (following-char) '(?\; ?{ ?}))
|
|
|
230 (setq crossedp t)
|
|
|
231 (if (= (following-char) ?:)
|
|
|
232 (setq maybe-labelp t))
|
|
|
233 (forward-char 1))
|
|
|
234 (setq lim (point)))
|
|
|
235 (forward-char 1))))
|
|
|
236 (error (setq crossedp nil)))
|
|
|
237 (goto-char here)
|
|
|
238 crossedp))
|
|
|
239
|
|
|
240
|
|
|
241 ;; Skipping of "syntactic whitespace", defined as lexical whitespace,
|
|
|
242 ;; C and C++ style comments, and preprocessor directives. Search no
|
|
|
243 ;; farther back or forward than optional LIM. If LIM is omitted,
|
|
|
244 ;; `beginning-of-defun' is used for backward skipping, point-max is
|
|
|
245 ;; used for forward skipping.
|
|
|
246
|
|
|
247 (defun c-forward-syntactic-ws (&optional lim)
|
|
|
248 ;; Forward skip of syntactic whitespace for Emacs 19.
|
|
|
249 (save-restriction
|
|
|
250 (let* ((lim (or lim (point-max)))
|
|
|
251 (here lim)
|
|
|
252 (hugenum (point-max)))
|
|
|
253 (narrow-to-region lim (point))
|
|
|
254 (while (/= here (point))
|
|
|
255 (setq here (point))
|
|
|
256 (forward-comment hugenum)
|
|
|
257 ;; skip preprocessor directives
|
|
|
258 (if (and (= (following-char) ?#)
|
|
|
259 (= (c-point 'boi) (point)))
|
|
|
260 (end-of-line)
|
|
|
261 )))))
|
|
|
262
|
|
|
263 (defun c-backward-syntactic-ws (&optional lim)
|
|
|
264 ;; Backward skip over syntactic whitespace for Emacs 19.
|
|
|
265 (save-restriction
|
|
|
266 (let* ((lim (or lim (c-point 'bod)))
|
|
|
267 (here lim)
|
|
|
268 (hugenum (- (point-max))))
|
|
|
269 (if (< lim (point))
|
|
|
270 (progn
|
|
|
271 (narrow-to-region lim (point))
|
|
|
272 (while (/= here (point))
|
|
|
273 (setq here (point))
|
|
|
274 (forward-comment hugenum)
|
|
|
275 (if (eq (c-in-literal lim) 'pound)
|
|
|
276 (beginning-of-line))
|
|
|
277 )))
|
|
|
278 )))
|
|
|
279
|
|
|
280
|
|
|
281 ;; Return `c' if in a C-style comment, `c++' if in a C++ style
|
|
|
282 ;; comment, `string' if in a string literal, `pound' if on a
|
|
|
283 ;; preprocessor line, or nil if not in a comment at all. Optional LIM
|
|
|
284 ;; is used as the backward limit of the search. If omitted, or nil,
|
|
|
285 ;; `beginning-of-defun' is used."
|
|
|
286
|
|
|
287 (defun c-in-literal (&optional lim)
|
|
|
288 ;; Determine if point is in a C++ literal. we cache the last point
|
|
|
289 ;; calculated if the cache is enabled
|
|
|
290 (if (and (boundp 'c-in-literal-cache)
|
|
|
291 c-in-literal-cache
|
|
|
292 (= (point) (aref c-in-literal-cache 0)))
|
|
|
293 (aref c-in-literal-cache 1)
|
|
|
294 (let ((rtn (save-excursion
|
|
|
295 (let* ((lim (or lim (c-point 'bod)))
|
|
|
296 (here (point))
|
|
|
297 (state (parse-partial-sexp lim (point))))
|
|
|
298 (cond
|
|
|
299 ((nth 3 state) 'string)
|
|
|
300 ((nth 4 state) (if (nth 7 state) 'c++ 'c))
|
|
|
301 ((progn
|
|
|
302 (goto-char here)
|
|
|
303 (beginning-of-line)
|
|
|
304 (looking-at "[ \t]*#"))
|
|
|
305 'pound)
|
|
|
306 (t nil))))))
|
|
|
307 ;; cache this result if the cache is enabled
|
|
|
308 (and (boundp 'c-in-literal-cache)
|
|
|
309 (setq c-in-literal-cache (vector (point) rtn)))
|
|
|
310 rtn)))
|
|
|
311
|
|
|
312
|
|
|
313 ;; utilities for moving and querying around syntactic elements
|
|
|
314
|
|
|
315 (defun c-parse-state ()
|
|
|
316 ;; Finds and records all open parens between some important point
|
|
|
317 ;; earlier in the file and point.
|
|
|
318 ;;
|
|
|
319 ;; if there's a state cache, return it
|
|
|
320 (if (boundp 'c-state-cache) c-state-cache
|
|
|
321 (let* (at-bob
|
|
|
322 (pos (save-excursion
|
|
|
323 ;; go back 2 bods, but ignore any bogus positions
|
|
|
324 ;; returned by beginning-of-defun (i.e. open paren
|
|
|
325 ;; in column zero)
|
|
|
326 (let ((cnt 2))
|
|
|
327 (while (not (or at-bob (zerop cnt)))
|
|
|
328 (beginning-of-defun)
|
|
|
329 (if (= (following-char) ?\{)
|
|
|
330 (setq cnt (1- cnt)))
|
|
|
331 (if (bobp)
|
|
|
332 (setq at-bob t))))
|
|
|
333 (point)))
|
|
|
334 (here (save-excursion
|
|
|
335 ;;(skip-chars-forward " \t}")
|
|
|
336 (point)))
|
|
|
337 (last-bod pos) (last-pos pos)
|
|
|
338 placeholder state sexp-end)
|
|
|
339 ;; cache last bod position
|
|
|
340 (while (catch 'backup-bod
|
|
|
341 (setq state nil)
|
|
|
342 (while (and pos (< pos here))
|
|
|
343 (setq last-pos pos)
|
|
|
344 (if (and (setq pos (c-safe (scan-lists pos 1 -1)))
|
|
|
345 (<= pos here))
|
|
|
346 (progn
|
|
|
347 (setq sexp-end (c-safe (scan-sexps (1- pos) 1)))
|
|
|
348 (if (and sexp-end
|
|
|
349 (<= sexp-end here))
|
|
|
350 ;; we want to record both the start and end
|
|
|
351 ;; of this sexp, but we only want to record
|
|
|
352 ;; the last-most of any of them before here
|
|
|
353 (progn
|
|
|
354 (if (= (char-after (1- pos)) ?\{)
|
|
|
355 (setq state (cons (cons (1- pos) sexp-end)
|
|
|
356 (if (consp (car state))
|
|
|
357 (cdr state)
|
|
|
358 state))))
|
|
|
359 (setq pos sexp-end))
|
|
|
360 ;; we're contained in this sexp so put pos on
|
|
|
361 ;; front of list
|
|
|
362 (setq state (cons (1- pos) state))))
|
|
|
363 ;; something bad happened. check to see if we
|
|
|
364 ;; crossed an unbalanced close brace. if so, we
|
|
|
365 ;; didn't really find the right `important bufpos'
|
|
|
366 ;; so lets back up and try again
|
|
|
367 (if (and (not pos) (not at-bob)
|
|
|
368 (setq placeholder
|
|
|
369 (c-safe (scan-lists last-pos 1 1)))
|
|
|
370 ;;(char-after (1- placeholder))
|
|
|
371 (<= placeholder here)
|
|
|
372 (= (char-after (1- placeholder)) ?\}))
|
|
|
373 (while t
|
|
|
374 (setq last-bod (c-safe (scan-lists last-bod -1 1)))
|
|
|
375 (if (not last-bod)
|
|
|
376 (error "unbalanced close brace at position %d"
|
|
|
377 (1- placeholder))
|
|
|
378 (setq at-bob (= last-bod (point-min))
|
|
|
379 pos last-bod)
|
|
|
380 (if (= (char-after last-bod) ?\{)
|
|
|
381 (throw 'backup-bod t)))
|
|
|
382 )) ;end-if
|
|
|
383 )) ;end-while
|
|
|
384 nil))
|
|
|
385 state)))
|
|
|
386
|
|
|
387 (defun c-whack-state (bufpos state)
|
|
|
388 ;; whack off any state information that appears on STATE which lies
|
|
|
389 ;; after the bounds of BUFPOS.
|
|
|
390 (let (newstate car)
|
|
|
391 (while state
|
|
|
392 (setq car (car state)
|
|
|
393 state (cdr state))
|
|
|
394 (if (consp car)
|
|
|
395 ;; just check the car, because in a balanced brace
|
|
|
396 ;; expression, it must be impossible for the corresponding
|
|
|
397 ;; close brace to be before point, but the open brace to be
|
|
|
398 ;; after.
|
|
|
399 (if (<= bufpos (car car))
|
|
|
400 nil ; whack it off
|
|
|
401 ;; its possible that the open brace is before bufpos, but
|
|
|
402 ;; the close brace is after. In that case, convert this
|
|
|
403 ;; to a non-cons element.
|
|
|
404 (if (<= bufpos (cdr car))
|
|
|
405 (setq newstate (append newstate (list (car car))))
|
|
|
406 ;; we know that both the open and close braces are
|
|
|
407 ;; before bufpos, so we also know that everything else
|
|
|
408 ;; on state is before bufpos, so we can glom up the
|
|
|
409 ;; whole thing and exit.
|
|
|
410 (setq newstate (append newstate (list car) state)
|
|
|
411 state nil)))
|
|
|
412 (if (<= bufpos car)
|
|
|
413 nil ; whack it off
|
|
|
414 ;; it's before bufpos, so everything else should too
|
|
|
415 (setq newstate (append newstate (list car) state)
|
|
|
416 state nil))))
|
|
|
417 newstate))
|
|
|
418
|
|
|
419 (defun c-hack-state (bufpos which state)
|
|
|
420 ;; Using BUFPOS buffer position, and WHICH (must be 'open or
|
|
|
421 ;; 'close), hack the c-parse-state STATE and return the results.
|
|
|
422 (if (eq which 'open)
|
|
|
423 (let ((car (car state)))
|
|
|
424 (if (or (null car)
|
|
|
425 (consp car)
|
|
|
426 (/= bufpos car))
|
|
|
427 (cons bufpos state)
|
|
|
428 state))
|
|
|
429 (if (not (eq which 'close))
|
|
|
430 (error "c-hack-state, bad argument: %s" which))
|
|
|
431 ;; 'close brace
|
|
|
432 (let ((car (car state))
|
|
|
433 (cdr (cdr state)))
|
|
|
434 (if (consp car)
|
|
|
435 (setq car (car cdr)
|
|
|
436 cdr (cdr cdr)))
|
|
|
437 ;; TBD: is this test relevant???
|
|
|
438 (if (consp car)
|
|
|
439 state ;on error, don't change
|
|
|
440 ;; watch out for balanced expr already on cdr of list
|
|
|
441 (cons (cons car bufpos)
|
|
|
442 (if (consp (car cdr))
|
|
|
443 (cdr cdr) cdr))
|
|
|
444 ))))
|
|
|
445
|
|
|
446 (defun c-adjust-state (from to shift state)
|
|
|
447 ;; Adjust all points in state that lie in the region FROM..TO by
|
|
|
448 ;; SHIFT amount (as would be returned by c-indent-line).
|
|
|
449 (mapcar
|
|
|
450 (function
|
|
|
451 (lambda (e)
|
|
|
452 (if (consp e)
|
|
|
453 (let ((car (car e))
|
|
|
454 (cdr (cdr e)))
|
|
|
455 (if (and (<= from car) (< car to))
|
|
|
456 (setcar e (+ shift car)))
|
|
|
457 (if (and (<= from cdr) (< cdr to))
|
|
|
458 (setcdr e (+ shift cdr))))
|
|
|
459 (if (and (<= from e) (< e to))
|
|
|
460 (setq e (+ shift e))))
|
|
|
461 e))
|
|
|
462 state))
|
|
|
463
|
|
|
464
|
|
|
465 (defun c-beginning-of-inheritance-list (&optional lim)
|
|
|
466 ;; Go to the first non-whitespace after the colon that starts a
|
|
|
467 ;; multiple inheritance introduction. Optional LIM is the farthest
|
|
|
468 ;; back we should search.
|
|
|
469 (let ((lim (or lim (c-point 'bod)))
|
|
|
470 (placeholder (progn
|
|
|
471 (back-to-indentation)
|
|
|
472 (point))))
|
|
|
473 (c-backward-syntactic-ws lim)
|
|
|
474 (while (and (> (point) lim)
|
|
|
475 (memq (preceding-char) '(?, ?:))
|
|
|
476 (progn
|
|
|
477 (beginning-of-line)
|
|
|
478 (setq placeholder (point))
|
|
|
479 (skip-chars-forward " \t")
|
|
|
480 (not (looking-at c-class-key))
|
|
|
481 ))
|
|
|
482 (c-backward-syntactic-ws lim))
|
|
|
483 (goto-char placeholder)
|
|
|
484 (skip-chars-forward "^:" (c-point 'eol))))
|
|
|
485
|
|
|
486 (defun c-beginning-of-macro (&optional lim)
|
|
|
487 ;; Go to the beginning of the macro. Right now we don't support
|
|
|
488 ;; multi-line macros too well
|
|
|
489 (back-to-indentation))
|
|
|
490
|
|
|
491 (defun c-in-method-def-p ()
|
|
|
492 ;; Return nil if we aren't in a method definition, otherwise the
|
|
|
493 ;; position of the initial [+-].
|
|
|
494 (save-excursion
|
|
|
495 (beginning-of-line)
|
|
|
496 (and c-method-key
|
|
|
497 (looking-at c-method-key)
|
|
|
498 (point))
|
|
|
499 ))
|
|
|
500
|
|
|
501 (defun c-just-after-func-arglist-p (&optional containing)
|
|
|
502 ;; Return t if we are between a function's argument list closing
|
|
|
503 ;; paren and its opening brace. Note that the list close brace
|
|
|
504 ;; could be followed by a "const" specifier or a member init hanging
|
|
|
505 ;; colon. Optional CONTAINING is position of containing s-exp open
|
|
|
506 ;; brace. If not supplied, point is used as search start.
|
|
|
507 (save-excursion
|
|
|
508 (c-backward-syntactic-ws)
|
|
|
509 (let ((checkpoint (or containing (point))))
|
|
|
510 (goto-char checkpoint)
|
|
|
511 ;; could be looking at const specifier
|
|
|
512 (if (and (= (preceding-char) ?t)
|
|
|
513 (forward-word -1)
|
|
|
514 (looking-at "\\<const\\>"))
|
|
|
515 (c-backward-syntactic-ws)
|
|
|
516 ;; otherwise, we could be looking at a hanging member init
|
|
|
517 ;; colon
|
|
|
518 (goto-char checkpoint)
|
|
|
519 (if (and (= (preceding-char) ?:)
|
|
|
520 (progn
|
|
|
521 (forward-char -1)
|
|
|
522 (c-backward-syntactic-ws)
|
|
|
523 (looking-at "[ \t\n]*:\\([^:]+\\|$\\)")))
|
|
|
524 nil
|
|
|
525 (goto-char checkpoint))
|
|
|
526 )
|
|
|
527 (and (= (preceding-char) ?\))
|
|
|
528 ;; check if we are looking at a method def
|
|
|
529 (or (not c-method-key)
|
|
|
530 (progn
|
|
|
531 (forward-sexp -1)
|
|
|
532 (forward-char -1)
|
|
|
533 (c-backward-syntactic-ws)
|
|
|
534 (not (or (= (preceding-char) ?-)
|
|
|
535 (= (preceding-char) ?+)
|
|
|
536 ;; or a class category
|
|
|
537 (progn
|
|
|
538 (forward-sexp -2)
|
|
|
539 (looking-at c-class-key))
|
|
|
540 )))))
|
|
|
541 )))
|
|
|
542
|
|
|
543 ;; defuns to look backwards for things
|
|
|
544 (defun c-backward-to-start-of-do (&optional lim)
|
|
|
545 ;; Move to the start of the last "unbalanced" do expression.
|
|
|
546 ;; Optional LIM is the farthest back to search. If none is found,
|
|
|
547 ;; nil is returned and point is left unchanged, otherwise t is returned.
|
|
|
548 (let ((do-level 1)
|
|
|
549 (case-fold-search nil)
|
|
|
550 (lim (or lim (c-point 'bod)))
|
|
|
551 (here (point))
|
|
|
552 foundp)
|
|
|
553 (while (not (zerop do-level))
|
|
|
554 ;; we protect this call because trying to execute this when the
|
|
|
555 ;; while is not associated with a do will throw an error
|
|
|
556 (condition-case nil
|
|
|
557 (progn
|
|
|
558 (backward-sexp 1)
|
|
|
559 (cond
|
|
|
560 ((memq (c-in-literal lim) '(c c++)))
|
|
|
561 ((looking-at "while\\b[^_]")
|
|
|
562 (setq do-level (1+ do-level)))
|
|
|
563 ((looking-at "do\\b[^_]")
|
|
|
564 (if (zerop (setq do-level (1- do-level)))
|
|
|
565 (setq foundp t)))
|
|
|
566 ((<= (point) lim)
|
|
|
567 (setq do-level 0)
|
|
|
568 (goto-char lim))))
|
|
|
569 (error
|
|
|
570 (goto-char lim)
|
|
|
571 (setq do-level 0))))
|
|
|
572 (if (not foundp)
|
|
|
573 (goto-char here))
|
|
|
574 foundp))
|
|
|
575
|
|
|
576 (defun c-backward-to-start-of-if (&optional lim)
|
|
|
577 ;; Move to the start of the last "unbalanced" if and return t. If
|
|
|
578 ;; none is found, and we are looking at an if clause, nil is
|
|
|
579 ;; returned. If none is found and we are looking at an else clause,
|
|
|
580 ;; an error is thrown.
|
|
|
581 (let ((if-level 1)
|
|
|
582 (here (c-point 'bol))
|
|
|
583 (case-fold-search nil)
|
|
|
584 (lim (or lim (c-point 'bod)))
|
|
|
585 (at-if (looking-at "if\\b[^_]")))
|
|
|
586 (catch 'orphan-if
|
|
|
587 (while (and (not (bobp))
|
|
|
588 (not (zerop if-level)))
|
|
|
589 (c-backward-syntactic-ws)
|
|
|
590 (condition-case nil
|
|
|
591 (backward-sexp 1)
|
|
|
592 (error
|
|
|
593 (if at-if
|
|
|
594 (throw 'orphan-if nil)
|
|
|
595 (error "No matching `if' found for `else' on line %d."
|
|
|
596 (1+ (count-lines 1 here))))))
|
|
|
597 (cond
|
|
|
598 ((looking-at "else\\b[^_]")
|
|
|
599 (setq if-level (1+ if-level)))
|
|
|
600 ((looking-at "if\\b[^_]")
|
|
|
601 ;; check for else if... skip over
|
|
|
602 (let ((here (point)))
|
|
|
603 (c-safe (forward-sexp -1))
|
|
|
604 (if (looking-at "\\<else\\>[ \t]+\\<if\\>")
|
|
|
605 nil
|
|
|
606 (setq if-level (1- if-level))
|
|
|
607 (goto-char here))))
|
|
|
608 ((< (point) lim)
|
|
|
609 (setq if-level 0)
|
|
|
610 (goto-char lim))
|
|
|
611 ))
|
|
|
612 t)))
|
|
|
613
|
|
|
614 (defun c-skip-conditional ()
|
|
|
615 ;; skip forward over conditional at point, including any predicate
|
|
|
616 ;; statements in parentheses. No error checking is performed.
|
|
|
617 (forward-sexp (cond
|
|
|
618 ;; else if()
|
|
|
619 ((looking-at "\\<else\\>[ \t]+\\<if\\>") 3)
|
|
|
620 ;; do, else, try, finally
|
|
|
621 ((looking-at "\\<\\(do\\|else\\|try\\|finally\\)\\>") 1)
|
|
|
622 ;; for, if, while, switch, catch, synchronized
|
|
|
623 (t 2))))
|
|
|
624
|
|
|
625 (defun c-skip-case-statement-forward (state &optional lim)
|
|
|
626 ;; skip forward over case/default bodies, with optional maximal
|
|
|
627 ;; limit. if no next case body is found, nil is returned and point
|
|
|
628 ;; is not moved
|
|
|
629 (let ((lim (or lim (point-max)))
|
|
|
630 (here (point))
|
|
|
631 donep foundp bufpos
|
|
|
632 (safepos (point))
|
|
|
633 (balanced (car state)))
|
|
|
634 ;; search until we've passed the limit, or we've found our match
|
|
|
635 (while (and (< (point) lim)
|
|
|
636 (not donep))
|
|
|
637 (setq safepos (point))
|
|
|
638 ;; see if we can find a case statement, not in a literal
|
|
|
639 (if (and (re-search-forward c-switch-label-key lim 'move)
|
|
|
640 (setq bufpos (match-beginning 0))
|
|
|
641 (not (c-in-literal safepos))
|
|
|
642 (/= bufpos here))
|
|
|
643 ;; if we crossed into a balanced sexp, we know the case is
|
|
|
644 ;; not part of our switch statement, so just bound over the
|
|
|
645 ;; sexp and keep looking.
|
|
|
646 (if (and (consp balanced)
|
|
|
647 (> bufpos (car balanced))
|
|
|
648 (< bufpos (cdr balanced)))
|
|
|
649 (goto-char (cdr balanced))
|
|
|
650 (goto-char bufpos)
|
|
|
651 (setq donep t
|
|
|
652 foundp t))))
|
|
|
653 (if (not foundp)
|
|
|
654 (goto-char here))
|
|
|
655 foundp))
|
|
|
656
|
|
|
657 (defun c-search-uplist-for-classkey (brace-state)
|
|
|
658 ;; search for the containing class, returning a 2 element vector if
|
|
|
659 ;; found. aref 0 contains the bufpos of the class key, and aref 1
|
|
|
660 ;; contains the bufpos of the open brace.
|
|
|
661 (if (null brace-state)
|
|
|
662 ;; no brace-state means we cannot be inside a class
|
|
|
663 nil
|
|
|
664 (let ((carcache (car brace-state))
|
|
|
665 search-start search-end)
|
|
|
666 (if (consp carcache)
|
|
|
667 ;; a cons cell in the first element means that there is some
|
|
|
668 ;; balanced sexp before the current bufpos. this we can
|
|
|
669 ;; ignore. the nth 1 and nth 2 elements define for us the
|
|
|
670 ;; search boundaries
|
|
|
671 (setq search-start (nth 2 brace-state)
|
|
|
672 search-end (nth 1 brace-state))
|
|
|
673 ;; if the car was not a cons cell then nth 0 and nth 1 define
|
|
|
674 ;; for us the search boundaries
|
|
|
675 (setq search-start (nth 1 brace-state)
|
|
|
676 search-end (nth 0 brace-state)))
|
|
|
677 ;; search-end cannot be a cons cell
|
|
|
678 (and (consp search-end)
|
|
|
679 (error "consp search-end: %s" search-end))
|
|
|
680 ;; if search-end is nil, or if the search-end character isn't an
|
|
|
681 ;; open brace, we are definitely not in a class
|
|
|
682 (if (or (not search-end)
|
|
|
683 (< search-end (point-min))
|
|
|
684 (/= (char-after search-end) ?{))
|
|
|
685 nil
|
|
|
686 ;; now, we need to look more closely at search-start. if
|
|
|
687 ;; search-start is nil, then our start boundary is really
|
|
|
688 ;; point-min.
|
|
|
689 (if (not search-start)
|
|
|
690 (setq search-start (point-min))
|
|
|
691 ;; if search-start is a cons cell, then we can start
|
|
|
692 ;; searching from the end of the balanced sexp just ahead of
|
|
|
693 ;; us
|
|
|
694 (if (consp search-start)
|
|
|
695 (setq search-start (cdr search-start))))
|
|
|
696 ;; now we can do a quick regexp search from search-start to
|
|
|
697 ;; search-end and see if we can find a class key. watch for
|
|
|
698 ;; class like strings in literals
|
|
|
699 (save-excursion
|
|
|
700 (save-restriction
|
|
|
701 (goto-char search-start)
|
|
|
702 (let ((search-key (concat c-class-key "\\|extern[^_]"))
|
|
|
703 foundp class match-end)
|
|
|
704 (while (and (not foundp)
|
|
|
705 (progn
|
|
|
706 (c-forward-syntactic-ws)
|
|
|
707 (> search-end (point)))
|
|
|
708 (re-search-forward search-key search-end t))
|
|
|
709 (setq class (match-beginning 0)
|
|
|
710 match-end (match-end 0))
|
|
|
711 (if (c-in-literal search-start)
|
|
|
712 nil ; its in a comment or string, ignore
|
|
|
713 (goto-char class)
|
|
|
714 (skip-chars-forward " \t\n")
|
|
|
715 (setq foundp (vector (c-point 'boi) search-end))
|
|
|
716 (cond
|
|
|
717 ;; check for embedded keywords
|
|
|
718 ((let ((char (char-after (1- class))))
|
|
|
719 (and char
|
|
|
720 (memq (char-syntax char) '(?w ?_))))
|
|
|
721 (goto-char match-end)
|
|
|
722 (setq foundp nil))
|
|
|
723 ;; make sure we're really looking at the start of a
|
|
|
724 ;; class definition, and not a forward decl, return
|
|
|
725 ;; arg, template arg list, or an ObjC or Java method.
|
|
|
726 ((and c-method-key
|
|
|
727 (re-search-forward c-method-key search-end t))
|
|
|
728 (setq foundp nil))
|
|
|
729 ;; Its impossible to define a regexp for this, and
|
|
|
730 ;; nearly so to do it programmatically.
|
|
|
731 ;;
|
|
|
732 ;; ; picks up forward decls
|
|
|
733 ;; = picks up init lists
|
|
|
734 ;; ) picks up return types
|
|
|
735 ;; > picks up templates, but remember that we can
|
|
|
736 ;; inherit from templates!
|
|
|
737 ((let ((skipchars "^;=)"))
|
|
|
738 ;; try to see if we found the `class' keyword
|
|
|
739 ;; inside a template arg list
|
|
|
740 (save-excursion
|
|
|
741 (skip-chars-backward "^<>" search-start)
|
|
|
742 (if (= (preceding-char) ?<)
|
|
|
743 (setq skipchars (concat skipchars ">"))))
|
|
|
744 (skip-chars-forward skipchars search-end)
|
|
|
745 (/= (point) search-end))
|
|
|
746 (setq foundp nil))
|
|
|
747 )))
|
|
|
748 foundp))
|
|
|
749 )))))
|
|
|
750
|
|
|
751 (defun c-inside-bracelist-p (containing-sexp brace-state)
|
|
|
752 ;; return the buffer position of the beginning of the brace list
|
|
|
753 ;; statement if we're inside a brace list, otherwise return nil.
|
|
|
754 ;; CONTAINING-SEXP is the buffer pos of the innermost containing
|
|
|
755 ;; paren. BRACE-STATE is the remainder of the state of enclosing braces
|
|
|
756 ;;
|
|
|
757 ;; N.B.: This algorithm can potentially get confused by cpp macros
|
|
|
758 ;; places in inconvenient locations. Its a trade-off we make for
|
|
|
759 ;; speed.
|
|
|
760 (or
|
|
|
761 ;; this will pick up enum lists
|
|
|
762 (condition-case ()
|
|
|
763 (save-excursion
|
|
|
764 (goto-char containing-sexp)
|
|
|
765 (forward-sexp -1)
|
|
|
766 (if (or (looking-at "enum[\t\n ]+")
|
|
|
767 (progn (forward-sexp -1)
|
|
|
768 (looking-at "enum[\t\n ]+")))
|
|
|
769 (point)))
|
|
|
770 (error nil))
|
|
|
771 ;; this will pick up array/aggregate init lists, even if they are nested.
|
|
|
772 (save-excursion
|
|
|
773 (let (bufpos failedp)
|
|
|
774 (while (and (not bufpos)
|
|
|
775 containing-sexp)
|
|
|
776 (if (consp containing-sexp)
|
|
|
777 (setq containing-sexp (car brace-state)
|
|
|
778 brace-state (cdr brace-state))
|
|
|
779 ;; see if significant character just before brace is an equal
|
|
|
780 (goto-char containing-sexp)
|
|
|
781 (setq failedp nil)
|
|
|
782 (condition-case ()
|
|
|
783 (progn
|
|
|
784 (forward-sexp -1)
|
|
|
785 (forward-sexp 1)
|
|
|
786 (c-forward-syntactic-ws containing-sexp))
|
|
|
787 (error (setq failedp t)))
|
|
|
788 (if (or failedp (/= (following-char) ?=))
|
|
|
789 ;; lets see if we're nested. find the most nested
|
|
|
790 ;; containing brace
|
|
|
791 (setq containing-sexp (car brace-state)
|
|
|
792 brace-state (cdr brace-state))
|
|
|
793 ;; we've hit the beginning of the aggregate list
|
|
|
794 (c-beginning-of-statement-1 (c-most-enclosing-brace brace-state))
|
|
|
795 (setq bufpos (point)))
|
|
|
796 ))
|
|
|
797 bufpos))
|
|
|
798 ))
|
|
|
799
|
|
|
800
|
|
|
801 (defun c-most-enclosing-brace (state)
|
|
|
802 ;; return the bufpos of the most enclosing brace that hasn't been
|
|
|
803 ;; narrowed out by any enclosing class, or nil if none was found
|
|
|
804 (let (enclosingp)
|
|
|
805 (while (and state (not enclosingp))
|
|
|
806 (setq enclosingp (car state)
|
|
|
807 state (cdr state))
|
|
|
808 (if (consp enclosingp)
|
|
|
809 (setq enclosingp nil)
|
|
|
810 (if (> (point-min) enclosingp)
|
|
|
811 (setq enclosingp nil))
|
|
|
812 (setq state nil)))
|
|
|
813 enclosingp))
|
|
|
814
|
|
|
815 (defun c-least-enclosing-brace (state)
|
|
|
816 ;; return the bufpos of the least (highest) enclosing brace that
|
|
|
817 ;; hasn't been narrowed out by any enclosing class, or nil if none
|
|
|
818 ;; was found.
|
|
|
819 (c-most-enclosing-brace (nreverse state)))
|
|
|
820
|
|
|
821 (defun c-safe-position (bufpos state)
|
|
|
822 ;; return the closest known safe position higher up than point
|
|
|
823 (let ((safepos nil))
|
|
|
824 (while state
|
|
|
825 (setq safepos
|
|
|
826 (if (consp (car state))
|
|
|
827 (cdr (car state))
|
|
|
828 (car state)))
|
|
|
829 (if (< safepos bufpos)
|
|
|
830 (setq state nil)
|
|
|
831 (setq state (cdr state))))
|
|
|
832 safepos))
|
|
|
833
|
|
|
834 (defun c-narrow-out-enclosing-class (state lim)
|
|
|
835 ;; narrow the buffer so that the enclosing class is hidden
|
|
|
836 (let (inclass-p)
|
|
|
837 (and state
|
|
|
838 (setq inclass-p (c-search-uplist-for-classkey state))
|
|
|
839 (narrow-to-region
|
|
|
840 (progn
|
|
|
841 (goto-char (1+ (aref inclass-p 1)))
|
|
|
842 (skip-chars-forward " \t\n" lim)
|
|
|
843 ;; if point is now left of the class opening brace, we're
|
|
|
844 ;; hosed, so try a different tact
|
|
|
845 (if (<= (point) (aref inclass-p 1))
|
|
|
846 (progn
|
|
|
847 (goto-char (1+ (aref inclass-p 1)))
|
|
|
848 (c-forward-syntactic-ws lim)))
|
|
|
849 (point))
|
|
|
850 ;; end point is the end of the current line
|
|
|
851 (progn
|
|
|
852 (goto-char lim)
|
|
|
853 (c-point 'eol))))
|
|
|
854 ;; return the class vector
|
|
|
855 inclass-p))
|
|
|
856
|
|
|
857
|
|
|
858 ;; This function implements the main decision tree for determining the
|
|
|
859 ;; syntactic analysis of the current line of code. Yes, it's huge and
|
|
|
860 ;; bloated!
|
|
|
861
|
|
|
862 (defun c-guess-basic-syntax ()
|
|
|
863 (save-excursion
|
|
|
864 (save-restriction
|
|
|
865 (beginning-of-line)
|
|
|
866 (let* ((indent-point (point))
|
|
|
867 (case-fold-search nil)
|
|
|
868 (fullstate (c-parse-state))
|
|
|
869 (state fullstate)
|
|
|
870 (in-method-intro-p (and (eq major-mode 'objc-mode)
|
|
|
871 c-method-key
|
|
|
872 (looking-at c-method-key)))
|
|
|
873 literal containing-sexp char-before-ip char-after-ip lim
|
|
|
874 syntax placeholder c-in-literal-cache inswitch-p
|
|
|
875 injava-inher
|
|
|
876 ;; narrow out any enclosing class or extern "C" block
|
|
|
877 (inclass-p (c-narrow-out-enclosing-class state indent-point))
|
|
|
878 (inextern-p (and inclass-p
|
|
|
879 (save-excursion
|
|
|
880 (save-restriction
|
|
|
881 (widen)
|
|
|
882 (goto-char (aref inclass-p 0))
|
|
|
883 (looking-at "extern[^_]")))))
|
|
|
884 )
|
|
|
885
|
|
|
886 ;; get the buffer position of the most nested opening brace,
|
|
|
887 ;; if there is one, and it hasn't been narrowed out
|
|
|
888 (save-excursion
|
|
|
889 (goto-char indent-point)
|
|
|
890 (skip-chars-forward " \t}")
|
|
|
891 (skip-chars-backward " \t")
|
|
|
892 (while (and state
|
|
|
893 (not in-method-intro-p)
|
|
|
894 (not containing-sexp))
|
|
|
895 (setq containing-sexp (car state)
|
|
|
896 state (cdr state))
|
|
|
897 (if (consp containing-sexp)
|
|
|
898 ;; if cdr == point, then containing sexp is the brace
|
|
|
899 ;; that opens the sexp we close
|
|
|
900 (if (= (cdr containing-sexp) (point))
|
|
|
901 (setq containing-sexp (car containing-sexp))
|
|
|
902 ;; otherwise, ignore this element
|
|
|
903 (setq containing-sexp nil))
|
|
|
904 ;; ignore the bufpos if its been narrowed out by the
|
|
|
905 ;; containing class
|
|
|
906 (if (<= containing-sexp (point-min))
|
|
|
907 (setq containing-sexp nil)))))
|
|
|
908
|
|
|
909 ;; set the limit on the farthest back we need to search
|
|
|
910 (setq lim (or containing-sexp
|
|
|
911 (if (consp (car fullstate))
|
|
|
912 (cdr (car fullstate))
|
|
|
913 nil)
|
|
|
914 (point-min)))
|
|
|
915
|
|
|
916 ;; cache char before and after indent point, and move point to
|
|
|
917 ;; the most likely position to perform the majority of tests
|
|
|
918 (goto-char indent-point)
|
|
|
919 (skip-chars-forward " \t")
|
|
|
920 (setq char-after-ip (following-char))
|
|
|
921 (c-backward-syntactic-ws lim)
|
|
|
922 (setq char-before-ip (preceding-char))
|
|
|
923 (goto-char indent-point)
|
|
|
924 (skip-chars-forward " \t")
|
|
|
925
|
|
|
926 ;; are we in a literal?
|
|
|
927 (setq literal (c-in-literal lim))
|
|
|
928
|
|
|
929 ;; now figure out syntactic qualities of the current line
|
|
|
930 (cond
|
|
|
931 ;; CASE 1: in a string.
|
|
|
932 ((memq literal '(string))
|
|
|
933 (c-add-syntax 'string (c-point 'bopl)))
|
|
|
934 ;; CASE 2: in a C or C++ style comment.
|
|
|
935 ((memq literal '(c c++))
|
|
|
936 ;; we need to catch multi-paragraph C comments
|
|
|
937 (while (and (zerop (forward-line -1))
|
|
|
938 (looking-at "^[ \t]*$")))
|
|
|
939 (c-add-syntax literal (c-point 'boi)))
|
|
|
940 ;; CASE 3: in a cpp preprocessor
|
|
|
941 ((eq literal 'pound)
|
|
|
942 (c-beginning-of-macro lim)
|
|
|
943 (c-add-syntax 'cpp-macro (c-point 'boi)))
|
|
|
944 ;; CASE 4: in an objective-c method intro
|
|
|
945 (in-method-intro-p
|
|
|
946 (c-add-syntax 'objc-method-intro (c-point 'boi)))
|
|
|
947 ;; CASE 5: Line is at top level.
|
|
|
948 ((null containing-sexp)
|
|
|
949 (cond
|
|
|
950 ;; CASE 5A: we are looking at a defun, class, or
|
|
|
951 ;; inline-inclass method opening brace
|
|
|
952 ((= char-after-ip ?{)
|
|
|
953 (cond
|
|
|
954 ;; CASE 5A.1: extern declaration
|
|
|
955 ((save-excursion
|
|
|
956 (goto-char indent-point)
|
|
|
957 (skip-chars-forward " \t")
|
|
|
958 (and (c-safe (progn (backward-sexp 2) t))
|
|
|
959 (looking-at "extern[^_]")
|
|
|
960 (progn
|
|
|
961 (setq placeholder (point))
|
|
|
962 (forward-sexp 1)
|
|
|
963 (c-forward-syntactic-ws)
|
|
|
964 (= (following-char) ?\"))))
|
|
|
965 (goto-char placeholder)
|
|
|
966 (c-add-syntax 'extern-lang-open (c-point 'boi)))
|
|
|
967 ;; CASE 5A.2: we are looking at a class opening brace
|
|
|
968 ((save-excursion
|
|
|
969 (goto-char indent-point)
|
|
|
970 (skip-chars-forward " \t{")
|
|
|
971 ;; TBD: watch out! there could be a bogus
|
|
|
972 ;; c-state-cache in place when we get here. we have
|
|
|
973 ;; to go through much chicanery to ignore the cache.
|
|
|
974 ;; But of course, there may not be! BLECH! BOGUS!
|
|
|
975 (let ((decl
|
|
|
976 (if (boundp 'c-state-cache)
|
|
|
977 (let ((old-cache c-state-cache))
|
|
|
978 (prog2
|
|
|
979 (makunbound 'c-state-cache)
|
|
|
980 (c-search-uplist-for-classkey (c-parse-state))
|
|
|
981 (setq c-state-cache old-cache)))
|
|
|
982 (c-search-uplist-for-classkey (c-parse-state))
|
|
|
983 )))
|
|
|
984 (and decl
|
|
|
985 (setq placeholder (aref decl 0)))
|
|
|
986 ))
|
|
|
987 (c-add-syntax 'class-open placeholder))
|
|
|
988 ;; CASE 5A.3: brace list open
|
|
|
989 ((save-excursion
|
|
|
990 (c-beginning-of-statement-1 lim)
|
|
|
991 ;; c-b-o-s could have left us at point-min
|
|
|
992 (and (bobp)
|
|
|
993 (c-forward-syntactic-ws indent-point))
|
|
|
994 (if (looking-at "typedef[^_]")
|
|
|
995 (progn (forward-sexp 1)
|
|
|
996 (c-forward-syntactic-ws indent-point)))
|
|
|
997 (setq placeholder (c-point 'boi))
|
|
|
998 (and (or (looking-at "enum[ \t\n]+")
|
|
|
999 (= char-before-ip ?=))
|
|
|
1000 (save-excursion
|
|
|
1001 (skip-chars-forward "^;(" indent-point)
|
|
|
1002 (not (memq (following-char) '(?\; ?\()))
|
|
|
1003 )))
|
|
|
1004 (c-add-syntax 'brace-list-open placeholder))
|
|
|
1005 ;; CASE 5A.4: inline defun open
|
|
|
1006 ((and inclass-p (not inextern-p))
|
|
|
1007 (c-add-syntax 'inline-open)
|
|
|
1008 (c-add-syntax 'inclass (aref inclass-p 0)))
|
|
|
1009 ;; CASE 5A.5: ordinary defun open
|
|
|
1010 (t
|
|
|
1011 (goto-char placeholder)
|
|
|
1012 (c-add-syntax 'defun-open (c-point 'bol))
|
|
|
1013 )))
|
|
|
1014 ;; CASE 5B: first K&R arg decl or member init
|
|
|
1015 ((c-just-after-func-arglist-p)
|
|
|
1016 (cond
|
|
|
1017 ;; CASE 5B.1: a member init
|
|
|
1018 ((or (= char-before-ip ?:)
|
|
|
1019 (= char-after-ip ?:))
|
|
|
1020 ;; this line should be indented relative to the beginning
|
|
|
1021 ;; of indentation for the topmost-intro line that contains
|
|
|
1022 ;; the prototype's open paren
|
|
|
1023 ;; TBD: is the following redundant?
|
|
|
1024 (if (= char-before-ip ?:)
|
|
|
1025 (forward-char -1))
|
|
|
1026 (c-backward-syntactic-ws lim)
|
|
|
1027 ;; TBD: is the preceding redundant?
|
|
|
1028 (if (= (preceding-char) ?:)
|
|
|
1029 (progn (forward-char -1)
|
|
|
1030 (c-backward-syntactic-ws lim)))
|
|
|
1031 (if (= (preceding-char) ?\))
|
|
|
1032 (backward-sexp 1))
|
|
|
1033 (setq placeholder (point))
|
|
|
1034 (save-excursion
|
|
|
1035 (and (c-safe (backward-sexp 1) t)
|
|
|
1036 (looking-at "throw[^_]")
|
|
|
1037 (c-safe (backward-sexp 1) t)
|
|
|
1038 (setq placeholder (point))))
|
|
|
1039 (goto-char placeholder)
|
|
|
1040 (c-add-syntax 'member-init-intro (c-point 'boi))
|
|
|
1041 ;; we don't need to add any class offset since this
|
|
|
1042 ;; should be relative to the ctor's indentation
|
|
|
1043 )
|
|
|
1044 ;; CASE 5B.2: K&R arg decl intro
|
|
|
1045 (c-recognize-knr-p
|
|
|
1046 (c-add-syntax 'knr-argdecl-intro (c-point 'boi))
|
|
|
1047 (and inclass-p (c-add-syntax 'inclass (aref inclass-p 0))))
|
|
|
1048 ;; CASE 5B.3: Nether region after a C++ or Java func
|
|
|
1049 ;; decl, which could include a `throws' declaration.
|
|
|
1050 (t
|
|
|
1051 (c-beginning-of-statement-1 lim)
|
|
|
1052 (c-add-syntax 'func-decl-cont (c-point 'boi))
|
|
|
1053 )))
|
|
|
1054 ;; CASE 5C: inheritance line. could be first inheritance
|
|
|
1055 ;; line, or continuation of a multiple inheritance
|
|
|
1056 ((or (and c-baseclass-key (looking-at c-baseclass-key))
|
|
|
1057 (and (or (= char-before-ip ?:)
|
|
|
1058 ;; watch out for scope operator
|
|
|
1059 (save-excursion
|
|
|
1060 (and (= char-after-ip ?:)
|
|
|
1061 (c-safe (progn (forward-char 1) t))
|
|
|
1062 (/= (following-char) ?:)
|
|
|
1063 )))
|
|
|
1064 (save-excursion
|
|
|
1065 (c-backward-syntactic-ws lim)
|
|
|
1066 (if (= char-before-ip ?:)
|
|
|
1067 (progn
|
|
|
1068 (forward-char -1)
|
|
|
1069 (c-backward-syntactic-ws lim)))
|
|
|
1070 (back-to-indentation)
|
|
|
1071 (looking-at c-class-key)))
|
|
|
1072 ;; for Java
|
|
|
1073 (and (eq major-mode 'java-mode)
|
|
|
1074 (let ((fence (save-excursion
|
|
|
1075 (c-beginning-of-statement-1 lim)
|
|
|
1076 (point)))
|
|
|
1077 cont done)
|
|
|
1078 (save-excursion
|
|
|
1079 (while (not done)
|
|
|
1080 (cond ((looking-at c-Java-special-key)
|
|
|
1081 (setq injava-inher (cons cont (point))
|
|
|
1082 done t))
|
|
|
1083 ((or (not (c-safe (forward-sexp -1) t))
|
|
|
1084 (<= (point) fence))
|
|
|
1085 (setq done t))
|
|
|
1086 )
|
|
|
1087 (setq cont t)))
|
|
|
1088 injava-inher)
|
|
|
1089 (not (c-crosses-statement-barrier-p (cdr injava-inher)
|
|
|
1090 (point)))
|
|
|
1091 ))
|
|
|
1092 (cond
|
|
|
1093 ;; CASE 5C.1: non-hanging colon on an inher intro
|
|
|
1094 ((= char-after-ip ?:)
|
|
|
1095 (c-backward-syntactic-ws lim)
|
|
|
1096 (c-add-syntax 'inher-intro (c-point 'boi))
|
|
|
1097 ;; don't add inclass symbol since relative point already
|
|
|
1098 ;; contains any class offset
|
|
|
1099 )
|
|
|
1100 ;; CASE 5C.2: hanging colon on an inher intro
|
|
|
1101 ((= char-before-ip ?:)
|
|
|
1102 (c-add-syntax 'inher-intro (c-point 'boi))
|
|
|
1103 (and inclass-p (c-add-syntax 'inclass (aref inclass-p 0))))
|
|
|
1104 ;; CASE 5C.3: in a Java implements/extends
|
|
|
1105 (injava-inher
|
|
|
1106 (let ((where (cdr injava-inher))
|
|
|
1107 (cont (car injava-inher)))
|
|
|
1108 (goto-char where)
|
|
|
1109 (cond ((looking-at "throws[ \t\n]")
|
|
|
1110 (c-add-syntax 'func-decl-cont
|
|
|
1111 (progn (c-beginning-of-statement-1 lim)
|
|
|
1112 (c-point 'boi))))
|
|
|
1113 (cont (c-add-syntax 'inher-cont where))
|
|
|
1114 (t (c-add-syntax 'inher-intro
|
|
|
1115 (progn (goto-char (cdr injava-inher))
|
|
|
1116 (c-beginning-of-statement-1 lim)
|
|
|
1117 (point))))
|
|
|
1118 )))
|
|
|
1119 ;; CASE 5C.4: a continued inheritance line
|
|
|
1120 (t
|
|
|
1121 (c-beginning-of-inheritance-list lim)
|
|
|
1122 (c-add-syntax 'inher-cont (point))
|
|
|
1123 ;; don't add inclass symbol since relative point already
|
|
|
1124 ;; contains any class offset
|
|
|
1125 )))
|
|
|
1126 ;; CASE 5D: this could be a top-level compound statement or a
|
|
|
1127 ;; member init list continuation
|
|
|
1128 ((= char-before-ip ?,)
|
|
|
1129 (goto-char indent-point)
|
|
|
1130 (c-backward-syntactic-ws lim)
|
|
|
1131 (while (and (< lim (point))
|
|
|
1132 (= (preceding-char) ?,))
|
|
|
1133 ;; this will catch member inits with multiple
|
|
|
1134 ;; line arglists
|
|
|
1135 (forward-char -1)
|
|
|
1136 (c-backward-syntactic-ws (c-point 'bol))
|
|
|
1137 (if (= (preceding-char) ?\))
|
|
|
1138 (backward-sexp 1))
|
|
|
1139 ;; now continue checking
|
|
|
1140 (beginning-of-line)
|
|
|
1141 (c-backward-syntactic-ws lim))
|
|
|
1142 (cond
|
|
|
1143 ;; CASE 5D.1: hanging member init colon, but watch out
|
|
|
1144 ;; for bogus matches on access specifiers inside classes.
|
|
|
1145 ((and (= (preceding-char) ?:)
|
|
|
1146 (save-excursion
|
|
|
1147 (forward-word -1)
|
|
|
1148 (not (looking-at c-access-key))))
|
|
|
1149 (goto-char indent-point)
|
|
|
1150 (c-backward-syntactic-ws lim)
|
|
|
1151 (c-safe (backward-sexp 1))
|
|
|
1152 (c-add-syntax 'member-init-cont (c-point 'boi))
|
|
|
1153 ;; we do not need to add class offset since relative
|
|
|
1154 ;; point is the member init above us
|
|
|
1155 )
|
|
|
1156 ;; CASE 5D.2: non-hanging member init colon
|
|
|
1157 ((progn
|
|
|
1158 (c-forward-syntactic-ws indent-point)
|
|
|
1159 (= (following-char) ?:))
|
|
|
1160 (skip-chars-forward " \t:")
|
|
|
1161 (c-add-syntax 'member-init-cont (point)))
|
|
|
1162 ;; CASE 5D.3: perhaps a multiple inheritance line?
|
|
|
1163 ((looking-at c-inher-key)
|
|
|
1164 (c-add-syntax 'inher-cont (c-point 'boi)))
|
|
|
1165 ;; CASE 5D.4: perhaps a template list continuation?
|
|
|
1166 ((save-excursion
|
|
|
1167 (skip-chars-backward "^<" lim)
|
|
|
1168 ;; not sure if this is the right test, but it should
|
|
|
1169 ;; be fast and mostly accurate.
|
|
|
1170 (and (= (preceding-char) ?<)
|
|
|
1171 (not (c-in-literal lim))))
|
|
|
1172 ;; we can probably indent it just like and arglist-cont
|
|
|
1173 (c-add-syntax 'arglist-cont (point)))
|
|
|
1174 ;; CASE 5D.5: perhaps a top-level statement-cont
|
|
|
1175 (t
|
|
|
1176 (c-beginning-of-statement-1 lim)
|
|
|
1177 ;; skip over any access-specifiers
|
|
|
1178 (and inclass-p c-access-key
|
|
|
1179 (while (looking-at c-access-key)
|
|
|
1180 (forward-line 1)))
|
|
|
1181 ;; skip over comments, whitespace
|
|
|
1182 (c-forward-syntactic-ws indent-point)
|
|
|
1183 (c-add-syntax 'statement-cont (c-point 'boi)))
|
|
|
1184 ))
|
|
|
1185 ;; CASE 5E: we are looking at a access specifier
|
|
|
1186 ((and inclass-p
|
|
|
1187 c-access-key
|
|
|
1188 (looking-at c-access-key))
|
|
|
1189 (c-add-syntax 'access-label (c-point 'bonl))
|
|
|
1190 (c-add-syntax 'inclass (aref inclass-p 0)))
|
|
|
1191 ;; CASE 5F: extern-lang-close?
|
|
|
1192 ((and inextern-p
|
|
|
1193 (= char-after-ip ?}))
|
|
|
1194 (c-add-syntax 'extern-lang-close (aref inclass-p 1)))
|
|
|
1195 ;; CASE 5G: we are looking at the brace which closes the
|
|
|
1196 ;; enclosing nested class decl
|
|
|
1197 ((and inclass-p
|
|
|
1198 (= char-after-ip ?})
|
|
|
1199 (save-excursion
|
|
|
1200 (save-restriction
|
|
|
1201 (widen)
|
|
|
1202 (forward-char 1)
|
|
|
1203 (and
|
|
|
1204 (condition-case nil
|
|
|
1205 (progn (backward-sexp 1) t)
|
|
|
1206 (error nil))
|
|
|
1207 (= (point) (aref inclass-p 1))
|
|
|
1208 ))))
|
|
|
1209 (save-restriction
|
|
|
1210 (widen)
|
|
|
1211 (goto-char (aref inclass-p 0))
|
|
|
1212 (c-add-syntax 'class-close (c-point 'boi))))
|
|
|
1213 ;; CASE 5H: we could be looking at subsequent knr-argdecls
|
|
|
1214 ((and c-recognize-knr-p
|
|
|
1215 ;; here we essentially use the hack that is used in
|
|
|
1216 ;; Emacs' c-mode.el to limit how far back we should
|
|
|
1217 ;; look. The assumption is made that argdecls are
|
|
|
1218 ;; indented at least one space and that function
|
|
|
1219 ;; headers are not indented.
|
|
|
1220 (let ((limit (save-excursion
|
|
|
1221 (re-search-backward "^[^ \^L\t\n#]" nil 'move)
|
|
|
1222 (point))))
|
|
|
1223 (save-excursion
|
|
|
1224 (c-backward-syntactic-ws limit)
|
|
|
1225 (setq placeholder (point))
|
|
|
1226 (while (and (memq (preceding-char) '(?\; ?,))
|
|
|
1227 (> (point) limit))
|
|
|
1228 (beginning-of-line)
|
|
|
1229 (setq placeholder (point))
|
|
|
1230 (c-backward-syntactic-ws limit))
|
|
|
1231 (and (= (preceding-char) ?\))
|
|
|
1232 (or (not c-method-key)
|
|
|
1233 (progn
|
|
|
1234 (forward-sexp -1)
|
|
|
1235 (forward-char -1)
|
|
|
1236 (c-backward-syntactic-ws)
|
|
|
1237 (not (or (= (preceding-char) ?-)
|
|
|
1238 (= (preceding-char) ?+)
|
|
|
1239 ;; or a class category
|
|
|
1240 (progn
|
|
|
1241 (forward-sexp -2)
|
|
|
1242 (looking-at c-class-key))
|
|
|
1243 )))))
|
|
|
1244 ))
|
|
|
1245 (save-excursion
|
|
|
1246 (c-beginning-of-statement-1)
|
|
|
1247 (not (looking-at "typedef[ \t\n]+"))))
|
|
|
1248 (goto-char placeholder)
|
|
|
1249 (c-add-syntax 'knr-argdecl (c-point 'boi)))
|
|
|
1250 ;; CASE 5I: we are at the topmost level, make sure we skip
|
|
|
1251 ;; back past any access specifiers
|
|
|
1252 ((progn
|
|
|
1253 (c-backward-syntactic-ws lim)
|
|
|
1254 (while (and inclass-p
|
|
|
1255 c-access-key
|
|
|
1256 (not (bobp))
|
|
|
1257 (save-excursion
|
|
|
1258 (c-safe (progn (backward-sexp 1) t))
|
|
|
1259 (looking-at c-access-key)))
|
|
|
1260 (backward-sexp 1)
|
|
|
1261 (c-backward-syntactic-ws lim))
|
|
|
1262 (or (bobp)
|
|
|
1263 (memq (preceding-char) '(?\; ?\}))))
|
|
|
1264 ;; real beginning-of-line could be narrowed out due to
|
|
|
1265 ;; enclosure in a class block
|
|
|
1266 (save-restriction
|
|
|
1267 (widen)
|
|
|
1268 (c-add-syntax 'topmost-intro (c-point 'bol))
|
|
|
1269 (if inclass-p
|
|
|
1270 (progn
|
|
|
1271 (goto-char (aref inclass-p 1))
|
|
|
1272 (if inextern-p
|
|
|
1273 (c-add-syntax 'inextern-lang)
|
|
|
1274 (c-add-syntax 'inclass (c-point 'boi)))))
|
|
|
1275 ))
|
|
|
1276 ;; CASE 5J: we are at an ObjC or Java method definition
|
|
|
1277 ;; continuation line.
|
|
|
1278 ((and c-method-key
|
|
|
1279 (progn
|
|
|
1280 (c-beginning-of-statement-1 lim)
|
|
|
1281 (beginning-of-line)
|
|
|
1282 (looking-at c-method-key)))
|
|
|
1283 (c-add-syntax 'objc-method-args-cont (point)))
|
|
|
1284 ;; CASE 5K: we are at a topmost continuation line
|
|
|
1285 (t
|
|
|
1286 (c-beginning-of-statement-1 lim)
|
|
|
1287 (c-forward-syntactic-ws)
|
|
|
1288 (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
|
|
|
1289 )) ; end CASE 5
|
|
|
1290 ;; CASE 6: line is an expression, not a statement. Most
|
|
|
1291 ;; likely we are either in a function prototype or a function
|
|
|
1292 ;; call argument list
|
|
|
1293 ((/= (char-after containing-sexp) ?{)
|
|
|
1294 (c-backward-syntactic-ws containing-sexp)
|
|
|
1295 (cond
|
|
|
1296 ;; CASE 6A: we are looking at the arglist closing paren
|
|
|
1297 ((and (/= char-before-ip ?,)
|
|
|
1298 (memq char-after-ip '(?\) ?\])))
|
|
|
1299 (goto-char containing-sexp)
|
|
|
1300 (c-add-syntax 'arglist-close (c-point 'boi)))
|
|
|
1301 ;; CASE 6B: we are looking at the first argument in an empty
|
|
|
1302 ;; argument list. Use arglist-close if we're actually
|
|
|
1303 ;; looking at a close paren or bracket.
|
|
|
1304 ((memq char-before-ip '(?\( ?\[))
|
|
|
1305 (goto-char containing-sexp)
|
|
|
1306 (c-add-syntax 'arglist-intro (c-point 'boi)))
|
|
|
1307 ;; CASE 6C: we are inside a conditional test clause. treat
|
|
|
1308 ;; these things as statements
|
|
|
1309 ((save-excursion
|
|
|
1310 (goto-char containing-sexp)
|
|
|
1311 (and (c-safe (progn (forward-sexp -1) t))
|
|
|
1312 (looking-at "\\<for\\>[^_]")))
|
|
|
1313 (goto-char (1+ containing-sexp))
|
|
|
1314 (c-forward-syntactic-ws indent-point)
|
|
|
1315 (c-beginning-of-statement-1 containing-sexp)
|
|
|
1316 (if (= char-before-ip ?\;)
|
|
|
1317 (c-add-syntax 'statement (point))
|
|
|
1318 (c-add-syntax 'statement-cont (point))
|
|
|
1319 ))
|
|
|
1320 ;; CASE 6D: maybe a continued method call. This is the case
|
|
|
1321 ;; when we are inside a [] bracketed exp, and what precede
|
|
|
1322 ;; the opening bracket is not an identifier.
|
|
|
1323 ((and c-method-key
|
|
|
1324 (= (char-after containing-sexp) ?\[)
|
|
|
1325 (save-excursion
|
|
|
1326 (goto-char (1- containing-sexp))
|
|
|
1327 (c-backward-syntactic-ws (c-point 'bod))
|
|
|
1328 (if (not (looking-at c-symbol-key))
|
|
|
1329 (c-add-syntax 'objc-method-call-cont containing-sexp))
|
|
|
1330 )))
|
|
|
1331 ;; CASE 6E: we are looking at an arglist continuation line,
|
|
|
1332 ;; but the preceding argument is on the same line as the
|
|
|
1333 ;; opening paren. This case includes multi-line
|
|
|
1334 ;; mathematical paren groupings, but we could be on a
|
|
|
1335 ;; for-list continuation line
|
|
|
1336 ((and (save-excursion
|
|
|
1337 (goto-char (1+ containing-sexp))
|
|
|
1338 (skip-chars-forward " \t")
|
|
|
1339 (not (eolp)))
|
|
|
1340 (save-excursion
|
|
|
1341 (c-beginning-of-statement-1 lim)
|
|
|
1342 (skip-chars-backward " \t([")
|
|
|
1343 (<= (point) containing-sexp)))
|
|
|
1344 (goto-char containing-sexp)
|
|
|
1345 (c-add-syntax 'arglist-cont-nonempty (c-point 'boi)))
|
|
|
1346 ;; CASE 6F: we are looking at just a normal arglist
|
|
|
1347 ;; continuation line
|
|
|
1348 (t (c-beginning-of-statement-1 containing-sexp)
|
|
|
1349 (forward-char 1)
|
|
|
1350 (c-forward-syntactic-ws indent-point)
|
|
|
1351 (c-add-syntax 'arglist-cont (c-point 'boi)))
|
|
|
1352 ))
|
|
|
1353 ;; CASE 7: func-local multi-inheritance line
|
|
|
1354 ((and c-baseclass-key
|
|
|
1355 (save-excursion
|
|
|
1356 (goto-char indent-point)
|
|
|
1357 (skip-chars-forward " \t")
|
|
|
1358 (looking-at c-baseclass-key)))
|
|
|
1359 (goto-char indent-point)
|
|
|
1360 (skip-chars-forward " \t")
|
|
|
1361 (cond
|
|
|
1362 ;; CASE 7A: non-hanging colon on an inher intro
|
|
|
1363 ((= char-after-ip ?:)
|
|
|
1364 (c-backward-syntactic-ws lim)
|
|
|
1365 (c-add-syntax 'inher-intro (c-point 'boi)))
|
|
|
1366 ;; CASE 7B: hanging colon on an inher intro
|
|
|
1367 ((= char-before-ip ?:)
|
|
|
1368 (c-add-syntax 'inher-intro (c-point 'boi)))
|
|
|
1369 ;; CASE 7C: a continued inheritance line
|
|
|
1370 (t
|
|
|
1371 (c-beginning-of-inheritance-list lim)
|
|
|
1372 (c-add-syntax 'inher-cont (point))
|
|
|
1373 )))
|
|
|
1374 ;; CASE 8: we are inside a brace-list
|
|
|
1375 ((setq placeholder (c-inside-bracelist-p containing-sexp state))
|
|
|
1376 (cond
|
|
|
1377 ;; CASE 8A: brace-list-close brace
|
|
|
1378 ((and (= char-after-ip ?})
|
|
|
1379 (c-safe (progn (forward-char 1)
|
|
|
1380 (backward-sexp 1)
|
|
|
1381 t))
|
|
|
1382 (= (point) containing-sexp))
|
|
|
1383 (c-add-syntax 'brace-list-close (c-point 'boi)))
|
|
|
1384 ;; CASE 8B: we're looking at the first line in a brace-list
|
|
|
1385 ((save-excursion
|
|
|
1386 (goto-char indent-point)
|
|
|
1387 (c-backward-syntactic-ws containing-sexp)
|
|
|
1388 (= (point) (1+ containing-sexp)))
|
|
|
1389 (goto-char containing-sexp)
|
|
|
1390 ;;(if (= char-after-ip ?{)
|
|
|
1391 ;;(c-add-syntax 'brace-list-open (c-point 'boi))
|
|
|
1392 (c-add-syntax 'brace-list-intro (c-point 'boi))
|
|
|
1393 )
|
|
|
1394 ;;)) ; end CASE 8B
|
|
|
1395 ;; CASE 8C: this is just a later brace-list-entry
|
|
|
1396 (t (goto-char (1+ containing-sexp))
|
|
|
1397 (c-forward-syntactic-ws indent-point)
|
|
|
1398 (if (= char-after-ip ?{)
|
|
|
1399 (c-add-syntax 'brace-list-open (point))
|
|
|
1400 (c-add-syntax 'brace-list-entry (point))
|
|
|
1401 )) ; end CASE 8C
|
|
|
1402 )) ; end CASE 8
|
|
|
1403 ;; CASE 9: A continued statement
|
|
|
1404 ((and (not (memq char-before-ip '(?\; ?} ?:)))
|
|
|
1405 (> (point)
|
|
|
1406 (save-excursion
|
|
|
1407 (c-beginning-of-statement-1 containing-sexp)
|
|
|
1408 (setq placeholder (point))))
|
|
|
1409 (/= placeholder containing-sexp))
|
|
|
1410 (goto-char indent-point)
|
|
|
1411 (skip-chars-forward " \t")
|
|
|
1412 (let ((after-cond-placeholder
|
|
|
1413 (save-excursion
|
|
|
1414 (goto-char placeholder)
|
|
|
1415 (if (looking-at c-conditional-key)
|
|
|
1416 (progn
|
|
|
1417 (c-safe (c-skip-conditional))
|
|
|
1418 (c-forward-syntactic-ws)
|
|
|
1419 (if (memq (following-char) '(?\;))
|
|
|
1420 (progn
|
|
|
1421 (forward-char 1)
|
|
|
1422 (c-forward-syntactic-ws)))
|
|
|
1423 (point))
|
|
|
1424 nil))))
|
|
|
1425 (cond
|
|
|
1426 ;; CASE 9A: substatement
|
|
|
1427 ((and after-cond-placeholder
|
|
|
1428 (>= after-cond-placeholder indent-point))
|
|
|
1429 (goto-char placeholder)
|
|
|
1430 (if (= char-after-ip ?{)
|
|
|
1431 (c-add-syntax 'substatement-open (c-point 'boi))
|
|
|
1432 (c-add-syntax 'substatement (c-point 'boi))))
|
|
|
1433 ;; CASE 9B: open braces for class or brace-lists
|
|
|
1434 ((= char-after-ip ?{)
|
|
|
1435 (cond
|
|
|
1436 ;; CASE 9B.1: class-open
|
|
|
1437 ((save-excursion
|
|
|
1438 (goto-char indent-point)
|
|
|
1439 (skip-chars-forward " \t{")
|
|
|
1440 (let ((decl (c-search-uplist-for-classkey (c-parse-state))))
|
|
|
1441 (and decl
|
|
|
1442 (setq placeholder (aref decl 0)))
|
|
|
1443 ))
|
|
|
1444 (c-add-syntax 'class-open placeholder))
|
|
|
1445 ;; CASE 9B.2: brace-list-open
|
|
|
1446 ((or (save-excursion
|
|
|
1447 (goto-char placeholder)
|
|
|
1448 (looking-at "\\<enum\\>"))
|
|
|
1449 (= char-before-ip ?=))
|
|
|
1450 (c-add-syntax 'brace-list-open placeholder))
|
|
|
1451 ;; CASE 9B.3: catch-all for unknown construct.
|
|
|
1452 (t
|
|
|
1453 ;; Can and should I add an extensibility hook here?
|
|
|
1454 ;; Something like c-recognize-hook so support for
|
|
|
1455 ;; unknown constructs could be added. It's probably a
|
|
|
1456 ;; losing proposition, so I dunno.
|
|
|
1457 (goto-char placeholder)
|
|
|
1458 (c-add-syntax 'statement-cont (c-point 'boi))
|
|
|
1459 (c-add-syntax 'block-open))
|
|
|
1460 ))
|
|
|
1461 ;; CASE 9C: iostream insertion or extraction operator
|
|
|
1462 ((looking-at "<<\\|>>")
|
|
|
1463 (goto-char placeholder)
|
|
|
1464 (and after-cond-placeholder
|
|
|
1465 (goto-char after-cond-placeholder))
|
|
|
1466 (while (and (re-search-forward "<<\\|>>" indent-point 'move)
|
|
|
1467 (c-in-literal placeholder)))
|
|
|
1468 ;; if we ended up at indent-point, then the first
|
|
|
1469 ;; streamop is on a separate line. Indent the line like
|
|
|
1470 ;; a statement-cont instead
|
|
|
1471 (if (/= (point) indent-point)
|
|
|
1472 (c-add-syntax 'stream-op (c-point 'boi))
|
|
|
1473 (c-backward-syntactic-ws lim)
|
|
|
1474 (c-add-syntax 'statement-cont (c-point 'boi))))
|
|
|
1475 ;; CASE 9D: continued statement. find the accurate
|
|
|
1476 ;; beginning of statement or substatement
|
|
|
1477 (t
|
|
|
1478 (c-beginning-of-statement-1 after-cond-placeholder)
|
|
|
1479 ;; KLUDGE ALERT! c-beginning-of-statement-1 can leave
|
|
|
1480 ;; us before the lim we're passing in. It should be
|
|
|
1481 ;; fixed, but I'm worried about side-effects at this
|
|
|
1482 ;; late date. Fix for v5.
|
|
|
1483 (goto-char (or (and after-cond-placeholder
|
|
|
1484 (max after-cond-placeholder (point)))
|
|
|
1485 (point)))
|
|
|
1486 (c-add-syntax 'statement-cont (point)))
|
|
|
1487 )))
|
|
|
1488 ;; CASE 10: an else clause?
|
|
|
1489 ((looking-at "\\<else\\>[^_]")
|
|
|
1490 (c-backward-to-start-of-if containing-sexp)
|
|
|
1491 (c-add-syntax 'else-clause (c-point 'boi)))
|
|
|
1492 ;; CASE 11: Statement. But what kind? Lets see if its a
|
|
|
1493 ;; while closure of a do/while construct
|
|
|
1494 ((progn
|
|
|
1495 (goto-char indent-point)
|
|
|
1496 (skip-chars-forward " \t")
|
|
|
1497 (and (looking-at "while\\b[^_]")
|
|
|
1498 (save-excursion
|
|
|
1499 (c-backward-to-start-of-do containing-sexp)
|
|
|
1500 (setq placeholder (point))
|
|
|
1501 (looking-at "do\\b[^_]"))
|
|
|
1502 ))
|
|
|
1503 (c-add-syntax 'do-while-closure placeholder))
|
|
|
1504 ;; CASE 12: A case or default label
|
|
|
1505 ((looking-at c-switch-label-key)
|
|
|
1506 (goto-char containing-sexp)
|
|
|
1507 ;; check for hanging braces
|
|
|
1508 (if (/= (point) (c-point 'boi))
|
|
|
1509 (forward-sexp -1))
|
|
|
1510 (c-add-syntax 'case-label (c-point 'boi)))
|
|
|
1511 ;; CASE 13: any other label
|
|
|
1512 ((looking-at c-label-key)
|
|
|
1513 (goto-char containing-sexp)
|
|
|
1514 (c-add-syntax 'label (c-point 'boi)))
|
|
|
1515 ;; CASE 14: block close brace, possibly closing the defun or
|
|
|
1516 ;; the class
|
|
|
1517 ((= char-after-ip ?})
|
|
|
1518 (let* ((lim (c-safe-position containing-sexp fullstate))
|
|
|
1519 (relpos (save-excursion
|
|
|
1520 (goto-char containing-sexp)
|
|
|
1521 (if (/= (point) (c-point 'boi))
|
|
|
1522 (c-beginning-of-statement-1 lim))
|
|
|
1523 (c-point 'boi))))
|
|
|
1524 (cond
|
|
|
1525 ;; CASE 14A: does this close an inline?
|
|
|
1526 ((let ((inclass-p (progn
|
|
|
1527 (goto-char containing-sexp)
|
|
|
1528 (c-search-uplist-for-classkey state))))
|
|
|
1529 ;; inextern-p in higher level let*
|
|
|
1530 (setq inextern-p (and inclass-p
|
|
|
1531 (progn
|
|
|
1532 (goto-char (aref inclass-p 0))
|
|
|
1533 (looking-at "extern[^_]"))))
|
|
|
1534 (and inclass-p (not inextern-p)))
|
|
|
1535 (c-add-syntax 'inline-close relpos))
|
|
|
1536 ;; CASE 14B: if there an enclosing brace that hasn't
|
|
|
1537 ;; been narrowed out by a class, then this is a
|
|
|
1538 ;; block-close
|
|
|
1539 ((and (not inextern-p)
|
|
|
1540 (c-most-enclosing-brace state))
|
|
|
1541 (c-add-syntax 'block-close relpos))
|
|
|
1542 ;; CASE 14C: find out whether we're closing a top-level
|
|
|
1543 ;; class or a defun
|
|
|
1544 (t
|
|
|
1545 (save-restriction
|
|
|
1546 (narrow-to-region (point-min) indent-point)
|
|
|
1547 (let ((decl (c-search-uplist-for-classkey (c-parse-state))))
|
|
|
1548 (if decl
|
|
|
1549 (c-add-syntax 'class-close (aref decl 0))
|
|
|
1550 (c-add-syntax 'defun-close relpos)))))
|
|
|
1551 )))
|
|
|
1552 ;; CASE 15: statement catchall
|
|
|
1553 (t
|
|
|
1554 ;; we know its a statement, but we need to find out if it is
|
|
|
1555 ;; the first statement in a block
|
|
|
1556 (goto-char containing-sexp)
|
|
|
1557 (forward-char 1)
|
|
|
1558 (c-forward-syntactic-ws indent-point)
|
|
|
1559 ;; now skip forward past any case/default clauses we might find.
|
|
|
1560 (while (or (c-skip-case-statement-forward fullstate indent-point)
|
|
|
1561 (and (looking-at c-switch-label-key)
|
|
|
1562 (not inswitch-p)))
|
|
|
1563 (setq inswitch-p t))
|
|
|
1564 ;; we want to ignore non-case labels when skipping forward
|
|
|
1565 (while (and (looking-at c-label-key)
|
|
|
1566 (goto-char (match-end 0)))
|
|
|
1567 (c-forward-syntactic-ws indent-point))
|
|
|
1568 (cond
|
|
|
1569 ;; CASE 15A: we are inside a case/default clause inside a
|
|
|
1570 ;; switch statement. find out if we are at the statement
|
|
|
1571 ;; just after the case/default label.
|
|
|
1572 ((and inswitch-p
|
|
|
1573 (progn
|
|
|
1574 (goto-char indent-point)
|
|
|
1575 (c-backward-syntactic-ws containing-sexp)
|
|
|
1576 (back-to-indentation)
|
|
|
1577 (setq placeholder (point))
|
|
|
1578 (looking-at c-switch-label-key)))
|
|
|
1579 (goto-char indent-point)
|
|
|
1580 (skip-chars-forward " \t")
|
|
|
1581 (if (= (following-char) ?{)
|
|
|
1582 (c-add-syntax 'statement-case-open placeholder)
|
|
|
1583 (c-add-syntax 'statement-case-intro placeholder)))
|
|
|
1584 ;; CASE 15B: continued statement
|
|
|
1585 ((= char-before-ip ?,)
|
|
|
1586 (c-add-syntax 'statement-cont (c-point 'boi)))
|
|
|
1587 ;; CASE 15C: a question/colon construct? But make sure
|
|
|
1588 ;; what came before was not a label, and what comes after
|
|
|
1589 ;; is not a globally scoped function call!
|
|
|
1590 ((or (and (memq char-before-ip '(?: ??))
|
|
|
1591 (save-excursion
|
|
|
1592 (goto-char indent-point)
|
|
|
1593 (c-backward-syntactic-ws lim)
|
|
|
1594 (back-to-indentation)
|
|
|
1595 (not (looking-at c-label-key))))
|
|
|
1596 (and (memq char-after-ip '(?: ??))
|
|
|
1597 (save-excursion
|
|
|
1598 (goto-char indent-point)
|
|
|
1599 (skip-chars-forward " \t")
|
|
|
1600 ;; watch out for scope operator
|
|
|
1601 (not (looking-at "::")))))
|
|
|
1602 (c-add-syntax 'statement-cont (c-point 'boi)))
|
|
|
1603 ;; CASE 15D: any old statement
|
|
|
1604 ((< (point) indent-point)
|
|
|
1605 (let ((safepos (c-most-enclosing-brace fullstate))
|
|
|
1606 relpos done)
|
|
|
1607 (goto-char indent-point)
|
|
|
1608 (c-beginning-of-statement-1 safepos)
|
|
|
1609 ;; It is possible we're on the brace that opens a nested
|
|
|
1610 ;; function.
|
|
|
1611 (if (and (= (following-char) ?{)
|
|
|
1612 (save-excursion
|
|
|
1613 (c-backward-syntactic-ws safepos)
|
|
|
1614 (/= (preceding-char) ?\;)))
|
|
|
1615 (c-beginning-of-statement-1 safepos))
|
|
|
1616 (if (and inswitch-p
|
|
|
1617 (looking-at c-switch-label-key))
|
|
|
1618 (progn
|
|
|
1619 (goto-char placeholder)
|
|
|
1620 (end-of-line)
|
|
|
1621 (forward-sexp -1)))
|
|
|
1622 (setq relpos (c-point 'boi))
|
|
|
1623 (while (and (not done)
|
|
|
1624 (<= safepos (point))
|
|
|
1625 (/= relpos (point)))
|
|
|
1626 (c-beginning-of-statement-1 safepos)
|
|
|
1627 (if (= relpos (c-point 'boi))
|
|
|
1628 (setq done t))
|
|
|
1629 (setq relpos (c-point 'boi)))
|
|
|
1630 (c-add-syntax 'statement relpos)
|
|
|
1631 (if (= char-after-ip ?{)
|
|
|
1632 (c-add-syntax 'block-open))))
|
|
|
1633 ;; CASE 15E: first statement in an inline, or first
|
|
|
1634 ;; statement in a top-level defun. we can tell this is it
|
|
|
1635 ;; if there are no enclosing braces that haven't been
|
|
|
1636 ;; narrowed out by a class (i.e. don't use bod here!)
|
|
|
1637 ((save-excursion
|
|
|
1638 (save-restriction
|
|
|
1639 (widen)
|
|
|
1640 (goto-char containing-sexp)
|
|
|
1641 (c-narrow-out-enclosing-class state containing-sexp)
|
|
|
1642 (not (c-most-enclosing-brace state))))
|
|
|
1643 (goto-char containing-sexp)
|
|
|
1644 ;; if not at boi, then defun-opening braces are hung on
|
|
|
1645 ;; right side, so we need a different relpos
|
|
|
1646 (if (/= (point) (c-point 'boi))
|
|
|
1647 (progn
|
|
|
1648 (c-backward-syntactic-ws)
|
|
|
1649 (c-safe (forward-sexp (if (= (preceding-char) ?\))
|
|
|
1650 -1 -2)))
|
|
|
1651 ;; looking at a Java throws clause following a
|
|
|
1652 ;; method's parameter list
|
|
|
1653 (c-beginning-of-statement-1)
|
|
|
1654 ))
|
|
|
1655 (c-add-syntax 'defun-block-intro (c-point 'boi)))
|
|
|
1656 ;; CASE 15F: first statement in a block
|
|
|
1657 (t (goto-char containing-sexp)
|
|
|
1658 (if (/= (point) (c-point 'boi))
|
|
|
1659 (c-beginning-of-statement-1
|
|
|
1660 (if (= (point) lim)
|
|
|
1661 (c-safe-position (point) state) lim)))
|
|
|
1662 (c-add-syntax 'statement-block-intro (c-point 'boi))
|
|
|
1663 (if (= char-after-ip ?{)
|
|
|
1664 (c-add-syntax 'block-open)))
|
|
|
1665 ))
|
|
|
1666 )
|
|
|
1667
|
|
|
1668 ;; now we need to look at any modifiers
|
|
|
1669 (goto-char indent-point)
|
|
|
1670 (skip-chars-forward " \t")
|
|
|
1671 ;; are we looking at a comment only line?
|
|
|
1672 (if (looking-at c-comment-start-regexp)
|
|
|
1673 (c-add-syntax 'comment-intro))
|
|
|
1674 ;; we might want to give additional offset to friends (in C++).
|
|
|
1675 (if (and (eq major-mode 'c++-mode)
|
|
|
1676 (looking-at c-C++-friend-key))
|
|
|
1677 (c-add-syntax 'friend))
|
|
|
1678 ;; return the syntax
|
|
|
1679 syntax))))
|
|
|
1680
|
|
|
1681
|
|
|
1682 ;; indent via syntactic language elements
|
|
|
1683 (defun c-indent-line (&optional syntax)
|
|
|
1684 ;; indent the current line as C/C++/ObjC code. Optional SYNTAX is the
|
|
|
1685 ;; syntactic information for the current line. Returns the amount of
|
|
|
1686 ;; indentation change
|
|
|
1687 (let* ((c-syntactic-context (or syntax (c-guess-basic-syntax)))
|
|
|
1688 (pos (- (point-max) (point)))
|
|
|
1689 (indent (apply '+ (mapcar 'c-get-offset c-syntactic-context)))
|
|
|
1690 (shift-amt (- (current-indentation) indent)))
|
|
|
1691 (and c-echo-syntactic-information-p
|
|
|
1692 (message "syntax: %s, indent= %d" c-syntactic-context indent))
|
|
|
1693 (if (zerop shift-amt)
|
|
|
1694 nil
|
|
|
1695 (delete-region (c-point 'bol) (c-point 'boi))
|
|
|
1696 (beginning-of-line)
|
|
|
1697 (indent-to indent))
|
|
|
1698 (if (< (point) (c-point 'boi))
|
|
|
1699 (back-to-indentation)
|
|
|
1700 ;; If initial point was within line's indentation, position after
|
|
|
1701 ;; the indentation. Else stay at same point in text.
|
|
|
1702 (if (> (- (point-max) pos) (point))
|
|
|
1703 (goto-char (- (point-max) pos)))
|
|
|
1704 )
|
|
|
1705 (run-hooks 'c-special-indent-hook)
|
|
|
1706 shift-amt))
|
|
|
1707
|
|
|
1708 (defun c-show-syntactic-information (arg)
|
|
|
1709 "Show syntactic information for current line.
|
|
|
1710 With universal argument, inserts the analysis as a comment on that line."
|
|
|
1711 (interactive "P")
|
|
|
1712 (let ((syntax (c-guess-basic-syntax)))
|
|
|
1713 (if (not (consp arg))
|
|
|
1714 (message "syntactic analysis: %s" syntax)
|
|
|
1715 (indent-for-comment)
|
|
|
1716 (insert (format "%s" syntax))
|
|
|
1717 ))
|
|
|
1718 (c-keep-region-active))
|
|
|
1719
|
|
|
1720
|
|
|
1721 (provide 'cc-engine)
|
|
|
1722 ;;; cc-engine.el ends here
|
