/[emacs]/emacs/lisp/progmodes/cc-engine.el
ViewVC logotype

Diff of /emacs/lisp/progmodes/cc-engine.el

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.24.2.3 by miles, Fri Nov 21 00:35:50 2003 UTC revision 1.24.2.4 by miles, Sat Sep 4 09:22:57 2004 UTC
# Line 1270  This function does not do any hidden buf Line 1270  This function does not do any hidden buf
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:
# Line 1906  This function does not do any hidden buf Line 1906  This function does not do any hidden buf
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)
# Line 1914  This function does not do any hidden buf Line 1914  This function does not do any hidden buf
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))
# Line 2124  This function does not do any hidden buf Line 2128  This function does not do any hidden buf
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)
# Line 2144  This function does not do any hidden buf Line 2148  This function does not do any hidden buf
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))
# Line 2384  outside any comment, macro or string lit Line 2388  outside any comment, macro or string lit
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
# Line 2401  subexpression is never tested before the Line 2408  subexpression is never tested before the
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))
# Line 2413  syntactic whitespace." Line 2424  syntactic whitespace."
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
# Line 2472  syntactic whitespace." Line 2485  syntactic whitespace."
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.
# Line 2479  syntactic whitespace." Line 2493  syntactic whitespace."
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
# Line 2501  syntactic whitespace." Line 2552  syntactic whitespace."
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)
# Line 4030  This function does not do any hidden buf Line 4085  This function does not do any hidden buf
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.
# Line 4199  This function does not do any hidden buf Line 4255  This function does not do any hidden buf
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))
# Line 4526  brace." Line 4585  brace."
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.
# Line 4536  brace." Line 4596  brace."
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
# Line 4972  brace." Line 5035  brace."
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)
# Line 6272  This function does not do any hidden buf Line 6346  This function does not do any hidden buf
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"))
# Line 6313  This function does not do any hidden buf Line 6387  This function does not do any hidden buf
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)))
# Line 6354  This function does not do any hidden buf Line 6428  This function does not do any hidden buf
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"))
# Line 6830  This function does not do any hidden buf Line 6904  This function does not do any hidden buf
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)

Legend:
Removed from v.1.24.2.3  
changed lines
  Added in v.1.24.2.4

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26