1270 |
|
|
1271 |
(when (and (= beg end) |
(when (and (= beg end) |
1272 |
(get-text-property beg 'c-in-sws) |
(get-text-property beg 'c-in-sws) |
1273 |
(not (bobp)) |
(> beg (point-min)) |
1274 |
(get-text-property (1- beg) 'c-in-sws)) |
(get-text-property (1- beg) 'c-in-sws)) |
1275 |
;; Ensure that an `c-in-sws' range gets broken. Note that it isn't |
;; Ensure that an `c-in-sws' range gets broken. Note that it isn't |
1276 |
;; safe to keep a range that was continuous before the change. E.g: |
;; safe to keep a range that was continuous before the change. E.g: |
1906 |
(if last-pos |
(if last-pos |
1907 |
;; Prepare to loop, but record the open paren only if it's |
;; Prepare to loop, but record the open paren only if it's |
1908 |
;; outside a macro or within the same macro as point, and |
;; outside a macro or within the same macro as point, and |
1909 |
;; if it is a "real" open paren and not some character |
;; if it is a legitimate open paren and not some character |
1910 |
;; that got an open paren syntax-table property. |
;; that got an open paren syntax-table property. |
1911 |
(progn |
(progn |
1912 |
(setq pos last-pos) |
(setq pos last-pos) |
1914 |
(save-excursion |
(save-excursion |
1915 |
(goto-char last-pos) |
(goto-char last-pos) |
1916 |
(not (c-beginning-of-macro)))) |
(not (c-beginning-of-macro)))) |
1917 |
(= (char-syntax (char-before last-pos)) ?\()) |
;; Check for known types of parens that we want |
1918 |
|
;; to record. The syntax table is not to be |
1919 |
|
;; trusted here since the caller might be using |
1920 |
|
;; e.g. `c++-template-syntax-table'. |
1921 |
|
(memq (char-before last-pos) '(?{ ?\( ?\[))) |
1922 |
(setq c-state-cache (cons (1- last-pos) c-state-cache)))) |
(setq c-state-cache (cons (1- last-pos) c-state-cache)))) |
1923 |
|
|
1924 |
(if (setq last-pos (c-up-list-forward pos)) |
(if (setq last-pos (c-up-list-forward pos)) |
2128 |
(when (c-major-mode-is 'pike-mode) |
(when (c-major-mode-is 'pike-mode) |
2129 |
;; Handle the `<operator> syntax in Pike. |
;; Handle the `<operator> syntax in Pike. |
2130 |
(let ((pos (point))) |
(let ((pos (point))) |
2131 |
(skip-chars-backward "!%&*+\\-/<=>^|~[]()") |
(skip-chars-backward "-!%&*+/<=>^|~[]()") |
2132 |
(and (if (< (skip-chars-backward "`") 0) |
(and (if (< (skip-chars-backward "`") 0) |
2133 |
t |
t |
2134 |
(goto-char pos) |
(goto-char pos) |
2148 |
(and (c-major-mode-is 'pike-mode) |
(and (c-major-mode-is 'pike-mode) |
2149 |
;; Handle the `<operator> syntax in Pike. |
;; Handle the `<operator> syntax in Pike. |
2150 |
(let ((pos (point))) |
(let ((pos (point))) |
2151 |
(if (and (< (skip-chars-backward "!%&*+\\-/<=>^|~[]()") 0) |
(if (and (< (skip-chars-backward "-!%&*+/<=>^|~[]()") 0) |
2152 |
(< (skip-chars-backward "`") 0) |
(< (skip-chars-backward "`") 0) |
2153 |
(looking-at c-symbol-key) |
(looking-at c-symbol-key) |
2154 |
(>= (match-end 0) pos)) |
(>= (match-end 0) pos)) |
2388 |
that region is taken as syntactically significant text. |
that region is taken as syntactically significant text. |
2389 |
|
|
2390 |
If PAREN-LEVEL is non-nil, an additional restriction is added to |
If PAREN-LEVEL is non-nil, an additional restriction is added to |
2391 |
ignore matches in nested paren sexps, and the search will also not go |
ignore matches in nested paren sexps. The search will also not go |
2392 |
outside the current paren sexp. |
outside the current list sexp, which has the effect that if the point |
2393 |
|
should be moved to BOUND when no match is found \(i.e. NOERROR is |
2394 |
|
neither nil nor t), then it will be at the closing paren if the end of |
2395 |
|
the current list sexp is encountered first. |
2396 |
|
|
2397 |
If NOT-INSIDE-TOKEN is non-nil, matches in the middle of tokens are |
If NOT-INSIDE-TOKEN is non-nil, matches in the middle of tokens are |
2398 |
ignored. Things like multicharacter operators and special symbols |
ignored. Things like multicharacter operators and special symbols |
2408 |
might be a good idea to include \\=\\= as a match alternative in it. |
might be a good idea to include \\=\\= as a match alternative in it. |
2409 |
|
|
2410 |
Optimization note: Matches might be missed if the \"look behind\" |
Optimization note: Matches might be missed if the \"look behind\" |
2411 |
subexpression should match the end of nonwhite syntactic whitespace, |
subexpression can match the end of nonwhite syntactic whitespace, |
2412 |
i.e. the end of comments or cpp directives. This since the function |
i.e. the end of comments or cpp directives. This since the function |
2413 |
skips over such things before resuming the search. It's also not safe |
skips over such things before resuming the search. It's on the other |
2414 |
to assume that the \"look behind\" subexpression never can match |
hand not safe to assume that the \"look behind\" subexpression never |
2415 |
syntactic whitespace." |
matches syntactic whitespace. |
2416 |
|
|
2417 |
|
Bug: Unbalanced parens inside cpp directives are currently not handled |
2418 |
|
correctly \(i.e. they don't get ignored as they should) when |
2419 |
|
PAREN-LEVEL is set." |
2420 |
|
|
2421 |
(or bound (setq bound (point-max))) |
(or bound (setq bound (point-max))) |
2422 |
(if paren-level (setq paren-level -1)) |
(if paren-level (setq paren-level -1)) |
2424 |
;;(message "c-syntactic-re-search-forward %s %s %S" (point) bound regexp) |
;;(message "c-syntactic-re-search-forward %s %s %S" (point) bound regexp) |
2425 |
|
|
2426 |
(let ((start (point)) |
(let ((start (point)) |
2427 |
(pos (point)) |
tmp |
2428 |
|
;; Start position for the last search. |
2429 |
|
search-pos |
2430 |
|
;; The `parse-partial-sexp' state between the start position |
2431 |
|
;; and the point. |
2432 |
|
state |
2433 |
|
;; The current position after the last state update. The next |
2434 |
|
;; `parse-partial-sexp' continues from here. |
2435 |
|
(state-pos (point)) |
2436 |
|
;; The position at which to check the state and the state |
2437 |
|
;; there. This is separate from `state-pos' since we might |
2438 |
|
;; need to back up before doing the next search round. |
2439 |
|
check-pos check-state |
2440 |
|
;; Last position known to end a token. |
2441 |
(last-token-end-pos (point-min)) |
(last-token-end-pos (point-min)) |
2442 |
match-pos found state check-pos check-state tmp) |
;; Set when a valid match is found. |
2443 |
|
found) |
2444 |
|
|
2445 |
(condition-case err |
(condition-case err |
2446 |
(while |
(while |
2447 |
(and |
(and |
2448 |
(re-search-forward regexp bound noerror) |
(progn |
2449 |
|
(setq search-pos (point)) |
2450 |
|
(re-search-forward regexp bound noerror)) |
2451 |
|
|
2452 |
(progn |
(progn |
2453 |
(setq match-pos (point) |
(setq state (parse-partial-sexp |
2454 |
state (parse-partial-sexp |
state-pos (match-beginning 0) paren-level nil state) |
2455 |
pos (match-beginning 0) paren-level nil state) |
state-pos (point)) |
|
pos (point)) |
|
2456 |
(if (setq check-pos (and lookbehind-submatch |
(if (setq check-pos (and lookbehind-submatch |
2457 |
|
(or (not paren-level) |
2458 |
|
(>= (car state) 0)) |
2459 |
(match-end lookbehind-submatch))) |
(match-end lookbehind-submatch))) |
2460 |
(setq check-state (parse-partial-sexp |
(setq check-state (parse-partial-sexp |
2461 |
pos check-pos paren-level nil state)) |
state-pos check-pos paren-level nil state)) |
2462 |
(setq check-pos pos |
(setq check-pos state-pos |
2463 |
check-state state)) |
check-state state)) |
2464 |
|
|
2465 |
;; If we got a look behind subexpression and get an |
;; NOTE: If we got a look behind subexpression and get |
2466 |
;; insignificant match in something that isn't |
;; an insignificant match in something that isn't |
2467 |
;; syntactic whitespace (i.e. strings or in nested |
;; syntactic whitespace (i.e. strings or in nested |
2468 |
;; parentheses), then we can never skip more than a |
;; parentheses), then we can never skip more than a |
2469 |
;; single character from the match position before |
;; single character from the match start position |
2470 |
;; continuing the search. That since the look behind |
;; (i.e. `state-pos' here) before continuing the |
2471 |
;; subexpression might match the end of the |
;; search. That since the look behind subexpression |
2472 |
;; insignificant region. |
;; might match the end of the insignificant region in |
2473 |
|
;; the next search. |
2474 |
|
|
2475 |
(cond |
(cond |
|
((setq tmp (elt check-state 3)) |
|
|
;; Match inside a string. |
|
|
(if (or lookbehind-submatch |
|
|
(not (integerp tmp))) |
|
|
(goto-char (min (1+ pos) bound)) |
|
|
;; Skip to the end of the string before continuing. |
|
|
(let ((ender (make-string 1 tmp)) (continue t)) |
|
|
(while (if (search-forward ender bound noerror) |
|
|
(progn |
|
|
(setq state (parse-partial-sexp |
|
|
pos (point) nil nil state) |
|
|
pos (point)) |
|
|
(elt state 3)) |
|
|
(setq continue nil))) |
|
|
continue))) |
|
|
|
|
2476 |
((elt check-state 7) |
((elt check-state 7) |
2477 |
;; Match inside a line comment. Skip to eol. Use |
;; Match inside a line comment. Skip to eol. Use |
2478 |
;; `re-search-forward' instead of `skip-chars-forward' to get |
;; `re-search-forward' instead of `skip-chars-forward' to get |
2485 |
|
|
2486 |
((and (not (elt check-state 5)) |
((and (not (elt check-state 5)) |
2487 |
(eq (char-before check-pos) ?/) |
(eq (char-before check-pos) ?/) |
2488 |
|
(not (c-get-char-property (1- check-pos) 'syntax-table)) |
2489 |
(memq (char-after check-pos) '(?/ ?*))) |
(memq (char-after check-pos) '(?/ ?*))) |
2490 |
;; Match in the middle of the opener of a block or line |
;; Match in the middle of the opener of a block or line |
2491 |
;; comment. |
;; comment. |
2493 |
(re-search-forward "[\n\r]" bound noerror) |
(re-search-forward "[\n\r]" bound noerror) |
2494 |
(search-forward "*/" bound noerror))) |
(search-forward "*/" bound noerror))) |
2495 |
|
|
2496 |
((and not-inside-token |
;; The last `parse-partial-sexp' above might have |
2497 |
(or (< check-pos last-token-end-pos) |
;; stopped short of the real check position if the end |
2498 |
(< check-pos |
;; of the current sexp was encountered in paren-level |
2499 |
(save-excursion |
;; mode. The checks above are always false in that |
2500 |
(goto-char check-pos) |
;; case, and since they can do better skipping in |
2501 |
(save-match-data |
;; lookbehind-submatch mode, we do them before |
2502 |
(c-end-of-current-token last-token-end-pos)) |
;; checking the paren level. |
2503 |
(setq last-token-end-pos (point)))))) |
|
2504 |
;; Match inside a token. |
((and paren-level |
2505 |
(cond ((<= (point) bound) |
(/= (setq tmp (car check-state)) 0)) |
2506 |
(goto-char (min (1+ pos) bound)) |
;; Check the paren level first since we're short of the |
2507 |
t) |
;; syntactic checking position if the end of the |
2508 |
(noerror nil) |
;; current sexp was encountered by `parse-partial-sexp'. |
2509 |
(t (signal 'search-failed "end of token")))) |
(if (> tmp 0) |
2510 |
|
|
2511 |
|
;; Inside a nested paren sexp. |
2512 |
|
(if lookbehind-submatch |
2513 |
|
;; See the NOTE above. |
2514 |
|
(progn (goto-char state-pos) t) |
2515 |
|
;; Skip out of the paren quickly. |
2516 |
|
(setq state (parse-partial-sexp state-pos bound 0 nil state) |
2517 |
|
state-pos (point))) |
2518 |
|
|
2519 |
|
;; Have exited the current paren sexp. |
2520 |
|
(if noerror |
2521 |
|
(progn |
2522 |
|
;; The last `parse-partial-sexp' call above |
2523 |
|
;; has left us just after the closing paren |
2524 |
|
;; in this case, so we can modify the bound |
2525 |
|
;; to leave the point at the right position |
2526 |
|
;; upon return. |
2527 |
|
(setq bound (1- (point))) |
2528 |
|
nil) |
2529 |
|
(signal 'search-failed (list regexp))))) |
2530 |
|
|
2531 |
|
((setq tmp (elt check-state 3)) |
2532 |
|
;; Match inside a string. |
2533 |
|
(if (or lookbehind-submatch |
2534 |
|
(not (integerp tmp))) |
2535 |
|
;; See the NOTE above. |
2536 |
|
(progn (goto-char state-pos) t) |
2537 |
|
;; Skip to the end of the string before continuing. |
2538 |
|
(let ((ender (make-string 1 tmp)) (continue t)) |
2539 |
|
(while (if (search-forward ender bound noerror) |
2540 |
|
(progn |
2541 |
|
(setq state (parse-partial-sexp |
2542 |
|
state-pos (point) nil nil state) |
2543 |
|
state-pos (point)) |
2544 |
|
(elt state 3)) |
2545 |
|
(setq continue nil))) |
2546 |
|
continue))) |
2547 |
|
|
2548 |
((save-excursion |
((save-excursion |
2549 |
(save-match-data |
(save-match-data |
2552 |
(c-end-of-macro) |
(c-end-of-macro) |
2553 |
(cond ((<= (point) bound) t) |
(cond ((<= (point) bound) t) |
2554 |
(noerror nil) |
(noerror nil) |
2555 |
(t (signal 'search-failed "end of macro")))) |
(t (signal 'search-failed (list regexp))))) |
2556 |
|
|
2557 |
((and paren-level |
((and not-inside-token |
2558 |
(/= (setq tmp (car check-state)) 0)) |
(or (< check-pos last-token-end-pos) |
2559 |
(if (> tmp 0) |
(< check-pos |
2560 |
;; Match inside a nested paren sexp. |
(save-excursion |
2561 |
(if lookbehind-submatch |
(goto-char check-pos) |
2562 |
(goto-char (min (1+ pos) bound)) |
(save-match-data |
2563 |
;; Skip out of the paren quickly. |
(c-end-of-current-token last-token-end-pos)) |
2564 |
(setq state (parse-partial-sexp pos bound 0 nil state) |
(setq last-token-end-pos (point)))))) |
2565 |
pos (point))) |
;; Inside a token. |
2566 |
;; Have exited the current paren sexp. The |
(if lookbehind-submatch |
2567 |
;; `parse-partial-sexp' above has left us just after the |
;; See the NOTE above. |
2568 |
;; closing paren in this case. Just make |
(goto-char state-pos) |
2569 |
;; `re-search-forward' above fail in the appropriate way; |
(goto-char (min last-token-end-pos bound)))) |
|
;; we'll adjust the leave off point below if necessary. |
|
|
(setq bound (point)))) |
|
2570 |
|
|
2571 |
(t |
(t |
2572 |
;; A real match. |
;; A real match. |
2573 |
(setq found t) |
(setq found t) |
2574 |
nil))))) |
nil))) |
2575 |
|
|
2576 |
|
;; Should loop to search again, but take care to avoid |
2577 |
|
;; looping on the same spot. |
2578 |
|
(or (/= search-pos (point)) |
2579 |
|
(if (= (point) bound) |
2580 |
|
(if noerror |
2581 |
|
nil |
2582 |
|
(signal 'search-failed (list regexp))) |
2583 |
|
(forward-char) |
2584 |
|
t)))) |
2585 |
|
|
2586 |
(error |
(error |
2587 |
(goto-char start) |
(goto-char start) |
2588 |
(signal (car err) (cdr err)))) |
(signal (car err) (cdr err)))) |
2589 |
|
|
2590 |
;;(message "c-syntactic-re-search-forward done %s" (or match-pos (point))) |
;;(message "c-syntactic-re-search-forward done %s" (or (match-end 0) (point))) |
2591 |
|
|
2592 |
(if found |
(if found |
2593 |
(progn |
(progn |
2594 |
(goto-char match-pos) |
(goto-char (match-end 0)) |
2595 |
match-pos) |
(match-end 0)) |
2596 |
|
|
2597 |
;; Search failed. Set point as appropriate. |
;; Search failed. Set point as appropriate. |
2598 |
(cond ((eq noerror t) |
(if (eq noerror t) |
2599 |
(goto-char start)) |
(goto-char start) |
2600 |
(paren-level |
(goto-char bound)) |
|
(if (eq (car (parse-partial-sexp pos bound -1 nil state)) -1) |
|
|
(backward-char))) |
|
|
(t |
|
|
(goto-char bound))) |
|
2601 |
nil))) |
nil))) |
2602 |
|
|
2603 |
(defun c-syntactic-skip-backward (skip-chars &optional limit) |
(defun c-syntactic-skip-backward (skip-chars &optional limit) |
4085 |
(defun c-forward-type () |
(defun c-forward-type () |
4086 |
;; Move forward over a type spec if at the beginning of one, |
;; Move forward over a type spec if at the beginning of one, |
4087 |
;; stopping at the next following token. Return t if it's a known |
;; stopping at the next following token. Return t if it's a known |
4088 |
;; type that can't be a name, 'known if it's an otherwise known type |
;; type that can't be a name or other expression, 'known if it's an |
4089 |
;; (according to `*-font-lock-extra-types'), 'prefix if it's a known |
;; otherwise known type (according to `*-font-lock-extra-types'), |
4090 |
;; prefix of a type, 'found if it's a type that matches one in |
;; 'prefix if it's a known prefix of a type, 'found if it's a type |
4091 |
;; `c-found-types', 'maybe if it's an identfier that might be a |
;; that matches one in `c-found-types', 'maybe if it's an identfier |
4092 |
;; type, or nil if it can't be a type (the point isn't moved then). |
;; that might be a type, or nil if it can't be a type (the point |
4093 |
;; The point is assumed to be at the beginning of a token. |
;; isn't moved then). The point is assumed to be at the beginning |
4094 |
|
;; of a token. |
4095 |
;; |
;; |
4096 |
;; Note that this function doesn't skip past the brace definition |
;; Note that this function doesn't skip past the brace definition |
4097 |
;; that might be considered part of the type, e.g. |
;; that might be considered part of the type, e.g. |
4255 |
;; don't let the existence of the operator itself promote two |
;; don't let the existence of the operator itself promote two |
4256 |
;; uncertain types to a certain one. |
;; uncertain types to a certain one. |
4257 |
(cond ((eq res t)) |
(cond ((eq res t)) |
4258 |
((or (eq res 'known) (memq res2 '(t known))) |
((eq res2 t) |
4259 |
(c-add-type id-start id-end) |
(c-add-type id-start id-end) |
4260 |
(when c-record-type-identifiers |
(when c-record-type-identifiers |
4261 |
(c-record-type-id id-range)) |
(c-record-type-id id-range)) |
4262 |
(setq res t)) |
(setq res t)) |
4263 |
|
((eq res 'known)) |
4264 |
|
((eq res2 'known) |
4265 |
|
(setq res 'known)) |
4266 |
((eq res 'found)) |
((eq res 'found)) |
4267 |
((eq res2 'found) |
((eq res2 'found) |
4268 |
(setq res 'found)) |
(setq res 'found)) |
4585 |
|
|
4586 |
;; `c-beginning-of-statement-1' stops at a block start, but we |
;; `c-beginning-of-statement-1' stops at a block start, but we |
4587 |
;; want to continue if the block doesn't begin a top level |
;; want to continue if the block doesn't begin a top level |
4588 |
;; construct, i.e. if it isn't preceded by ';', '}', ':', or bob. |
;; construct, i.e. if it isn't preceded by ';', '}', ':', bob, |
4589 |
|
;; or an open paren. |
4590 |
(let ((beg (point)) tentative-move) |
(let ((beg (point)) tentative-move) |
4591 |
(while (and |
(while (and |
4592 |
;; Must check with c-opt-method-key in ObjC mode. |
;; Must check with c-opt-method-key in ObjC mode. |
4596 |
(progn |
(progn |
4597 |
(c-backward-syntactic-ws lim) |
(c-backward-syntactic-ws lim) |
4598 |
(not (memq (char-before) '(?\; ?} ?: nil)))) |
(not (memq (char-before) '(?\; ?} ?: nil)))) |
4599 |
|
(save-excursion |
4600 |
|
(backward-char) |
4601 |
|
(not (looking-at "\\s("))) |
4602 |
;; Check that we don't move from the first thing in a |
;; Check that we don't move from the first thing in a |
4603 |
;; macro to its header. |
;; macro to its header. |
4604 |
(not (eq (setq tentative-move |
(not (eq (setq tentative-move |
5035 |
(condition-case () |
(condition-case () |
5036 |
(save-excursion |
(save-excursion |
5037 |
(let ((beg (point)) |
(let ((beg (point)) |
5038 |
end type) |
inner-beg end type) |
5039 |
(c-forward-syntactic-ws) |
(c-forward-syntactic-ws) |
5040 |
(if (eq (char-after) ?\() |
(if (eq (char-after) ?\() |
5041 |
(progn |
(progn |
5042 |
(forward-char 1) |
(forward-char 1) |
5043 |
(c-forward-syntactic-ws) |
(c-forward-syntactic-ws) |
5044 |
|
(setq inner-beg (point)) |
5045 |
(setq type (assq (char-after) c-special-brace-lists))) |
(setq type (assq (char-after) c-special-brace-lists))) |
5046 |
(if (setq type (assq (char-after) c-special-brace-lists)) |
(if (setq type (assq (char-after) c-special-brace-lists)) |
5047 |
(progn |
(progn |
5048 |
|
(setq inner-beg (point)) |
5049 |
(c-backward-syntactic-ws) |
(c-backward-syntactic-ws) |
5050 |
(forward-char -1) |
(forward-char -1) |
5051 |
(setq beg (if (eq (char-after) ?\() |
(setq beg (if (eq (char-after) ?\() |
5052 |
(point) |
(point) |
5053 |
nil))))) |
nil))))) |
5054 |
(if (and beg type) |
(if (and beg type) |
5055 |
(if (and (c-safe (goto-char beg) |
(if (and (c-safe |
5056 |
(c-forward-sexp 1) |
(goto-char beg) |
5057 |
(setq end (point)) |
(c-forward-sexp 1) |
5058 |
(= (char-before) ?\))) |
(setq end (point)) |
5059 |
(c-safe (goto-char beg) |
(= (char-before) ?\))) |
5060 |
(forward-char 1) |
(c-safe |
5061 |
|
(goto-char inner-beg) |
5062 |
|
(if (looking-at "\\s(") |
5063 |
|
;; Check balancing of the inner paren |
5064 |
|
;; below. |
5065 |
|
(progn |
5066 |
(c-forward-sexp 1) |
(c-forward-sexp 1) |
5067 |
;; Kludges needed to handle inner |
t) |
5068 |
;; chars both with and without |
;; If the inner char isn't a paren then |
5069 |
;; paren syntax. |
;; we can't check balancing, so just |
5070 |
(or (/= (char-syntax (char-before)) ?\)) |
;; check the char before the outer |
5071 |
(= (char-before) (cdr type))))) |
;; closing paren. |
5072 |
|
(goto-char end) |
5073 |
|
(backward-char) |
5074 |
|
(c-backward-syntactic-ws) |
5075 |
|
(= (char-before) (cdr type))))) |
5076 |
(if (or (/= (char-syntax (char-before)) ?\)) |
(if (or (/= (char-syntax (char-before)) ?\)) |
5077 |
(= (progn |
(= (progn |
5078 |
(c-forward-syntactic-ws) |
(c-forward-syntactic-ws) |
6346 |
(goto-char containing-sexp) |
(goto-char containing-sexp) |
6347 |
(setq placeholder (c-point 'boi)) |
(setq placeholder (c-point 'boi)) |
6348 |
(if (and (c-safe (backward-up-list 1) t) |
(if (and (c-safe (backward-up-list 1) t) |
6349 |
(> (point) placeholder)) |
(>= (point) placeholder)) |
6350 |
(progn |
(progn |
6351 |
(forward-char) |
(forward-char) |
6352 |
(skip-chars-forward " \t")) |
(skip-chars-forward " \t")) |
6387 |
(goto-char containing-sexp) |
(goto-char containing-sexp) |
6388 |
(setq placeholder (c-point 'boi)) |
(setq placeholder (c-point 'boi)) |
6389 |
(when (and (c-safe (backward-up-list 1) t) |
(when (and (c-safe (backward-up-list 1) t) |
6390 |
(> (point) placeholder)) |
(>= (point) placeholder)) |
6391 |
(forward-char) |
(forward-char) |
6392 |
(skip-chars-forward " \t") |
(skip-chars-forward " \t") |
6393 |
(setq placeholder (point))) |
(setq placeholder (point))) |
6428 |
(goto-char containing-sexp) |
(goto-char containing-sexp) |
6429 |
(setq placeholder (c-point 'boi)) |
(setq placeholder (c-point 'boi)) |
6430 |
(if (and (c-safe (backward-up-list 1) t) |
(if (and (c-safe (backward-up-list 1) t) |
6431 |
(> (point) placeholder)) |
(>= (point) placeholder)) |
6432 |
(progn |
(progn |
6433 |
(forward-char) |
(forward-char) |
6434 |
(skip-chars-forward " \t")) |
(skip-chars-forward " \t")) |
6904 |
((vectorp offset) offset) |
((vectorp offset) offset) |
6905 |
((null offset) nil) |
((null offset) nil) |
6906 |
((listp offset) |
((listp offset) |
6907 |
|
(if (eq (car offset) 'quote) |
6908 |
|
(error |
6909 |
|
"Setting in c-offsets-alist element \"(%s . '%s)\" was mistakenly quoted" |
6910 |
|
symbol (cadr offset))) |
6911 |
(let (done) |
(let (done) |
6912 |
(while (and (not done) offset) |
(while (and (not done) offset) |
6913 |
(setq done (c-evaluate-offset (car offset) langelem symbol) |
(setq done (c-evaluate-offset (car offset) langelem symbol) |