From b2acd789585ac55b73175ef4f30d970638c6f06d Mon Sep 17 00:00:00 2001 From: "Richard M. Stallman" Date: Sun, 8 Mar 1998 06:49:04 +0000 Subject: [PATCH] (c-inside-bracelist-p): Fix for enum test. (c-collect-line-comments): Require same comment start column. (c-guess-basic-syntax): Fixes for nesting of and repeated defun-open's inside extern and namespace clauses. This is done by passing a relpos to `inextern-lang' and `innamespace'. Also, the relpos in `defun-open' is no longer always bol. It's always bol when on the top level, however. Changed cases: 5A.5, 5I, 14A. (c-forward-token-1, c-backward-token-1): New functions to move by tokens. c-guess-basic-syntax): Fixes for Java 1.1 array initialization brace lists. --- lisp/progmodes/cc-engine.el | 156 +++++++++++++++++++++++++----------- 1 file changed, 108 insertions(+), 48 deletions(-) diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el index f4f37379a5b..31a26c3c3c3 100644 --- a/lisp/progmodes/cc-engine.el +++ b/lisp/progmodes/cc-engine.el @@ -270,6 +270,53 @@ (c-beginning-of-macro)) (if lim (goto-char (max (point) lim))))) + +;; Moving by tokens, where a token is defined as all symbols and +;; identifiers which aren't syntactic whitespace. COUNT specifies the +;; number of tokens to move forward; a negative COUNT moves backward. +;; If BALANCED is true, move over balanced parens, otherwise move into +;; them. Also, if BALANCED is true, never move out of an enclosing +;; paren. LIM sets the limit for the movement. Point is always left +;; at the beginning of a token or at LIM. Returns the number of +;; tokens left to move (positive or negative). If BALANCED is true, a +;; move over a balanced paren counts as one. + +(defun c-forward-token-1 (&optional count balanced lim) + (let* ((jump-syntax (if balanced + '(?w ?_ ?\" ?\\ ?/ ?$ ?' ?\( ?\)) + '(?w ?_ ?\" ?\\ ?/ ?$ ?')))) + (or count (setq count 1)) + (condition-case nil + (while (progn + (c-forward-syntactic-ws lim) + (> count 0)) + (if (memq (char-syntax (char-after)) jump-syntax) + (goto-char (scan-sexps (point) 1)) + (forward-char)) + (setq count (1- count))) + (error + (and lim (> (point) lim) (goto-char lim)))) + count)) + +(defun c-backward-token-1 (&optional count balanced lim) + (let* ((jump-syntax (if balanced + '(?w ?_ ?\" ?\\ ?/ ?$ ?' ?\( ?\)) + '(?w ?_ ?\" ?\\ ?/ ?$ ?'))) + last) + (or count (setq count 1)) + (condition-case nil + (while (> count 0) + (setq last (point)) + (c-backward-syntactic-ws lim) + (if (memq (char-syntax (char-before)) jump-syntax) + (goto-char (scan-sexps (point) -1)) + (backward-char)) + (setq count (1- count))) + (error + (goto-char last) + (and lim (< (point) lim) (goto-char lim)))) + count)) + ;; Return `c' if in a C-style comment, `c++' if in a C++ style ;; comment, `string' if in a string literal, `pound' if on a @@ -376,24 +423,30 @@ ;; If the argument is a cons of two buffer positions (such as ;; returned by c-literal-limits), and that range contains a C++ ;; style line comment, then an extended range is returned that - ;; contains all adjacent line comments (i.e. all comments with no - ;; empty lines or non-whitespace characters between them). - ;; Otherwise the argument is returned. + ;; contains all adjacent line comments (i.e. all comments that + ;; starts in the same column with no empty lines or non-whitespace + ;; characters between them). Otherwise the argument is returned. (save-excursion (condition-case nil (if (and (consp range) (progn (goto-char (car range)) (looking-at "//"))) - (let ((beg (point))) + (let ((col (current-column)) + (beg (point)) + (end (cdr range))) (while (and (not (bobp)) (forward-comment -1) - (looking-at "//")) + (looking-at "//") + (= col (current-column))) (setq beg (point))) - (cons beg (progn - (goto-char (cdr range)) - (while (looking-at "[ \t]*//") - (forward-comment 1)) - (point)))) + (goto-char end) + (while (progn + (skip-chars-forward " \t") + (and (looking-at "//") + (= col (current-column)))) + (forward-comment 1) + (setq end (point))) + (cons beg end)) range) (error range)))) @@ -850,35 +903,32 @@ ;; speed. (or ;; this will pick up enum lists - (condition-case () - (save-excursion - (goto-char containing-sexp) - (forward-sexp -1) - (if (and (or (looking-at "enum[\t\n ]+") - (progn (forward-sexp -1) - (looking-at "enum[\t\n ]+"))) - (progn (c-end-of-statement-1) - (> (point) containing-sexp))) - (point))) - (error nil)) + (c-safe + (save-excursion + (goto-char containing-sexp) + (forward-sexp -1) + (let (bracepos) + (if (and (or (looking-at "enum[\t\n ]+") + (progn (forward-sexp -1) + (looking-at "enum[\t\n ]+"))) + (setq bracepos (c-safe (scan-lists (point) 1 -1))) + (not (c-crosses-statement-barrier-p (point) + (- bracepos 2)))) + (point))))) ;; this will pick up array/aggregate init lists, even if they are nested. (save-excursion - (let (bufpos failedp) + (let (bufpos okp) (while (and (not bufpos) containing-sexp) (if (consp containing-sexp) (setq containing-sexp (car brace-state) brace-state (cdr brace-state)) - ;; see if significant character just before brace is an equal + ;; see if the open brace is preceded by a = in this statement (goto-char containing-sexp) - (setq failedp nil) - (condition-case () - (progn - (forward-sexp -1) - (forward-sexp 1) - (c-forward-syntactic-ws containing-sexp)) - (error (setq failedp t))) - (if (or failedp (not (eq (char-after) ?=))) + (setq okp t) + (while (and (setq okp (= (c-backward-token-1 1 t) 0)) + (not (memq (char-after) '(?= ?{ ?\;))))) + (if (not (and okp (eq (char-after) ?=))) ;; lets see if we're nested. find the most nested ;; containing brace (setq containing-sexp (car brace-state) @@ -1109,7 +1159,12 @@ (c-forward-syntactic-ws indent-point))) (setq placeholder (c-point 'boi)) (and (or (looking-at "enum[ \t\n]+") - (eq char-before-ip ?=)) + (save-excursion + (goto-char indent-point) + (while (and (> (point) placeholder) + (= (c-backward-token-1 1 t) 0) + (/= (char-after) ?=))) + (eq (char-after) ?=))) (save-excursion (skip-chars-forward "^;(" indent-point) (not (memq (char-after) '(?\; ?\())) @@ -1122,7 +1177,9 @@ ;; CASE 5A.5: ordinary defun open (t (goto-char placeholder) - (c-add-syntax 'defun-open (c-point 'bol)) + (if inclass-p + (c-add-syntax 'defun-open (c-point 'boi)) + (c-add-syntax 'defun-open (c-point 'bol))) ))) ;; CASE 5B: first K&R arg decl or member init ((c-just-after-func-arglist-p) @@ -1302,7 +1359,7 @@ (looking-at c-access-key)) (c-add-syntax 'access-label (c-point 'bonl)) (c-add-syntax 'inclass (aref inclass-p 0))) - ;; CASE 5F: extern-lang-close? + ;; CASE 5F: extern-lang-close or namespace-close? ((and inenclosing-p (eq char-after-ip ?})) (setq tmpsymbol (if (eq inenclosing-p 'extern) @@ -1389,9 +1446,9 @@ (goto-char (aref inclass-p 0))) (cond ((eq inenclosing-p 'extern) - (c-add-syntax 'inextern-lang)) + (c-add-syntax 'inextern-lang (c-point 'boi))) ((eq inenclosing-p 'namespace) - (c-add-syntax 'innamespace)) + (c-add-syntax 'innamespace (c-point 'boi))) (t (c-add-syntax 'inclass (c-point 'boi)))) )) )) @@ -1566,7 +1623,12 @@ ((or (save-excursion (goto-char placeholder) (looking-at "\\")) - (eq char-before-ip ?=)) + (save-excursion + (goto-char indent-point) + (while (and (> (point) placeholder) + (= (c-backward-token-1 1 t) 0) + (/= (char-after) ?=))) + (eq (char-after) ?=))) (c-add-syntax 'brace-list-open placeholder)) ;; CASE 9B.3: catch-all for unknown construct. (t @@ -1642,17 +1704,15 @@ (c-beginning-of-statement-1 lim)) (c-point 'boi)))) (cond - ;; CASE 14A: does this close an inline? - ((let ((inclass-p (progn - (goto-char containing-sexp) - (c-search-uplist-for-classkey state)))) - ;; inenclosing-p in higher level let* - (setq inenclosing-p (and inclass-p - (progn - (goto-char (aref inclass-p 0)) - (looking-at c-extra-toplevel-key)))) - (and inclass-p (not inenclosing-p))) - (c-add-syntax 'inline-close relpos)) + ;; CASE 14A: does this close an inline or a function in + ;; an extern block or namespace? + ((progn + (goto-char containing-sexp) + (setq placeholder (c-search-uplist-for-classkey state))) + (goto-char (aref placeholder 0)) + (if (looking-at c-extra-toplevel-key) + (c-add-syntax 'defun-close relpos) + (c-add-syntax 'inline-close relpos))) ;; CASE 14B: if there an enclosing brace that hasn't ;; been narrowed out by a class, then this is a ;; block-close -- 2.39.2