diff options
| -rw-r--r-- | lisp/progmodes/cc-defs.el | 59 | ||||
| -rw-r--r-- | lisp/progmodes/cc-fonts.el | 33 | ||||
| -rw-r--r-- | lisp/progmodes/cc-langs.el | 22 | ||||
| -rw-r--r-- | lisp/progmodes/cc-mode.el | 294 |
4 files changed, 311 insertions, 97 deletions
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el index 377a981598a..85a4085e490 100644 --- a/lisp/progmodes/cc-defs.el +++ b/lisp/progmodes/cc-defs.el @@ -1171,6 +1171,63 @@ been put there by c-put-char-property. POINT remains unchanged." nil ,from ,to ,value nil -property-)) ;; GNU Emacs `(c-clear-char-property-with-value-function ,from ,to ,property ,value))) + +(defun c-clear-char-property-with-value-on-char-function (from to property + value char) + "Remove all text-properties PROPERTY with value VALUE on +characters with value CHAR from the region [FROM, TO), as tested +by `equal'. These properties are assumed to be over individual +characters, having been put there by c-put-char-property. POINT +remains unchanged." + (let ((place from) + ) + (while ; loop round occurrences of (PROPERTY VALUE) + (progn + (while ; loop round changes in PROPERTY till we find VALUE + (and + (< place to) + (not (equal (get-text-property place property) value))) + (setq place (c-next-single-property-change place property nil to))) + (< place to)) + (if (eq (char-after place) char) + (remove-text-properties place (1+ place) (cons property nil))) + ;; Do we have to do anything with stickiness here? + (setq place (1+ place))))) + +(defmacro c-clear-char-property-with-value-on-char (from to property value char) + "Remove all text-properties PROPERTY with value VALUE on +characters with value CHAR from the region [FROM, TO), as tested +by `equal'. These properties are assumed to be over individual +characters, having been put there by c-put-char-property. POINT +remains unchanged." + (if c-use-extents + ;; XEmacs + `(let ((-property- ,property) + (-char- ,char)) + (map-extents (lambda (ext val) + (if (and (equal (extent-property ext -property-) val) + (eq (char-after + (extent-start-position ext)) + -char-)) + (delete-extent ext))) + nil ,from ,to ,value nil -property-)) + ;; Gnu Emacs + `(c-clear-char-property-with-value-on-char-function ,from ,to ,property + ,value ,char))) + +(defmacro c-put-char-properties-on-char (from to property value char) + ;; This needs to be a macro because `property' passed to + ;; `c-put-char-property' must be a constant. + "Put the text property PROPERTY with value VALUE on characters +with value CHAR in the region [FROM to)." + `(let ((skip-string (concat "^" (list ,char))) + (-to- ,to)) + (save-excursion + (goto-char ,from) + (while (progn (skip-chars-forward skip-string -to-) + (< (point) -to-)) + (c-put-char-property (point) ,property ,value) + (forward-char))))) ;; Macros to put overlays (Emacs) or extents (XEmacs) on buffer text. ;; For our purposes, these are characterized by being possible to @@ -1228,6 +1285,8 @@ been put there by c-put-char-property. POINT remains unchanged." (def-edebug-spec c-put-char-property t) (def-edebug-spec c-get-char-property t) (def-edebug-spec c-clear-char-property t) +(def-edebug-spec c-clear-char-property-with-value-on-char t) +(def-edebug-spec c-put-char-properties-on-char t) (def-edebug-spec c-clear-char-properties t) (def-edebug-spec c-put-overlay t) (def-edebug-spec c-delete-overlay t) diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el index 00812530357..66f2575f49f 100644 --- a/lisp/progmodes/cc-fonts.el +++ b/lisp/progmodes/cc-fonts.el @@ -702,6 +702,36 @@ stuff. Used on level 1 and higher." t) (c-put-font-lock-face start (1+ start) 'font-lock-warning-face))))) +(defun c-font-lock-invalid-single-quotes (limit) + ;; This function will be called from font-lock for a region bounded by POINT + ;; and LIMIT, as though it were to identify a keyword for + ;; font-lock-keyword-face. It always returns NIL to inhibit this and + ;; prevent a repeat invocation. See elisp/lispref page "Search-based + ;; Fontification". + ;; + ;; This function fontifies invalid single quotes with + ;; `font-lock-warning-face'. These are the single quotes which + ;; o - aren't inside a literal; + ;; o - are marked with a syntax-table text property value '(1); and + ;; o - are NOT marked with a non-null c-digit-separator property. + (let ((limits (c-literal-limits)) + state beg end) + (if limits + (goto-char (cdr limits))) ; Even for being in a ' ' + (while (< (point) limit) + (setq beg (point)) + (setq state (parse-partial-sexp (point) limit nil nil nil 'syntax-table)) + (setq end (point)) + (goto-char beg) + (while (progn (skip-chars-forward "^'" end) + (< (point) end)) + (if (and (equal (c-get-char-property (point) 'syntax-table) '(1)) + (not (c-get-char-property (point) 'c-digit-separator))) + (c-put-font-lock-face (point) (1+ (point)) font-lock-warning-face)) + (forward-char)) + (parse-partial-sexp end limit nil nil state 'syntax-table))) + nil) + (c-lang-defconst c-basic-matchers-before "Font lock matchers for basic keywords, labels, references and various other easily recognizable things that should be fontified before generic @@ -723,6 +753,9 @@ casts and declarations are fontified. Used on level 2 and higher." (concat ".\\(" c-string-limit-regexp "\\)") '((c-font-lock-invalid-string))) + ;; Invalid single quotes. + c-font-lock-invalid-single-quotes + ;; Fontify C++ raw strings. ,@(when (c-major-mode-is 'c++-mode) '(c-font-lock-raw-strings)) diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el index 1ce0fbf7d05..8be806094cd 100644 --- a/lisp/progmodes/cc-langs.el +++ b/lisp/progmodes/cc-langs.el @@ -474,18 +474,19 @@ so that all identifiers are recognized as words.") ;; The value here may be a list of functions or a single function. t nil c++ '(c-extend-region-for-CPP -; c-before-after-change-extend-region-for-lambda-capture ; doesn't seem needed. c-before-change-check-raw-strings c-before-change-check-<>-operators c-depropertize-CPP - c-before-after-change-digit-quote c-invalidate-macro-cache - c-truncate-bs-cache) + c-truncate-bs-cache + c-parse-quotes-before-change) (c objc) '(c-extend-region-for-CPP c-depropertize-CPP c-invalidate-macro-cache - c-truncate-bs-cache) - ;; java 'c-before-change-check-<>-operators + c-truncate-bs-cache + c-parse-quotes-before-change) + java 'c-parse-quotes-before-change + ;; 'c-before-change-check-<>-operators awk 'c-awk-record-region-clear-NL) (c-lang-defvar c-get-state-before-change-functions (let ((fs (c-lang-const c-get-state-before-change-functions))) @@ -515,18 +516,19 @@ parameters \(point-min) and \(point-max).") t '(c-depropertize-new-text c-change-expand-fl-region) (c objc) '(c-depropertize-new-text + c-parse-quotes-after-change c-extend-font-lock-region-for-macros c-neutralize-syntax-in-and-mark-CPP c-change-expand-fl-region) c++ '(c-depropertize-new-text + c-parse-quotes-after-change c-extend-font-lock-region-for-macros -; c-before-after-change-extend-region-for-lambda-capture ; doesn't seem needed. - c-before-after-change-digit-quote c-after-change-re-mark-raw-strings c-neutralize-syntax-in-and-mark-CPP c-restore-<>-properties c-change-expand-fl-region) java '(c-depropertize-new-text + c-parse-quotes-after-change c-restore-<>-properties c-change-expand-fl-region) awk '(c-depropertize-new-text @@ -609,6 +611,12 @@ EOL terminated statements." (c c++ objc) t) (c-lang-defvar c-has-bitfields (c-lang-const c-has-bitfields)) +(c-lang-defconst c-has-quoted-numbers + "Whether the language has numbers quoted like 4'294'967'295." + t nil + c++ t) +(c-lang-defvar c-has-quoted-numbers (c-lang-const c-has-quoted-numbers)) + (c-lang-defconst c-modified-constant "Regexp that matches a “modified” constant literal such as \"L\\='a\\='\", a “long character”. In particular, this recognizes forms of constant diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el index a501ebba256..c5ee60f7d79 100644 --- a/lisp/progmodes/cc-mode.el +++ b/lisp/progmodes/cc-mode.el @@ -1083,101 +1083,215 @@ Note that the style variables are always made local to the buffer." (forward-line)) ; no infinite loop with, e.g., "#//" ))))) -(defun c-before-after-change-digit-quote (beg end &optional old-len) - ;; This function either removes or applies the punctuation value ('(1)) of - ;; the `syntax-table' text property on single quote marks which are - ;; separator characters in long integer literals, e.g. "4'294'967'295". It - ;; applies to both decimal/octal and hex literals. (FIXME (2016-06-10): it - ;; should also apply to binary literals.) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Parsing of quotes. +;; +;; Valid digit separators in numbers will get the syntax-table "punctuation" +;; property, '(1), and also the text property `c-digit-separator' value t. +;; +;; Invalid other quotes (i.e. those not validly bounding a single character, +;; or escaped character) will get the syntax-table "punctuation" property, +;; '(1), too. +;; +;; Note that, for convenience, these properties are applied even inside +;; comments and strings. + +(defconst c-maybe-quoted-number-head + (concat + "\\(0\\(" + "\\([Xx]\\([0-9a-fA-F]\\('[0-9a-fA-F]\\|[0-9a-fA-F]\\)*'?\\)?\\)" + "\\|" + "\\([Bb]\\([01]\\('[01]\\|[01]\\)*'?\\)?\\)" + "\\|" + "\\('[0-7]\\|[0-7]\\)*'?" + "\\)" + "\\|" + "[1-9]\\('[0-9]\\|[0-9]\\)*'?" + "\\)") + "Regexp matching the head of a numeric literal, including with digit separators.") + +(defun c-quoted-number-head-before-point () + ;; Return non-nil when the head of a possibly quoted number is found + ;; immediately before point. The value returned in this case is the buffer + ;; position of the start of the head. + (when c-has-quoted-numbers + (save-excursion + (let ((here (point)) + ) + (skip-chars-backward "0-9a-fA-F'") + (if (and (memq (char-before) '(?x ?X)) + (eq (char-before (1- (point))) ?0)) + (backward-char 2)) + (while (and (search-forward-regexp c-maybe-quoted-number-head here t) + (< (match-end 0) here))) + (and (eq (match-end 0) here) (match-beginning 0)))))) + +(defconst c-maybe-quoted-number-tail + (concat + "\\(" + "\\([xX']?[0-9a-fA-F]\\('[0-9a-fA-F]\\|[0-9a-fA-F]\\)*\\)" + "\\|" + "\\([bB']?[01]\\('[01]\\|[01]\\)*\\)" + "\\|" + "\\('?[0-9]\\('[0-9]\\|[0-9]\\)*\\)" + "\\)") + "Regexp matching the tail of a numeric literal, including with digit separators. +Note that this is a strict tail, so won't match, e.g. \"0x....\".") + +(defun c-quoted-number-tail-after-point () + ;; Return non-nil when a proper tail of a possibly quoted number is found + ;; immediately after point. The value returned in this case is the buffer + ;; position of the end of the tail. + (when c-has-quoted-numbers + (and (looking-at c-maybe-quoted-number-tail) + (match-end 0)))) + +(defconst c-maybe-quoted-number + (concat + "\\(0\\(" + "\\([Xx][0-9a-fA-F]\\('[0-9a-fA-F]\\|[0-9a-fA-F]\\)*\\)" + "\\|" + "\\([Bb][01]\\('[01]\\|[01]\\)*\\)" + "\\|" + "\\('[0-7]\\|[0-7]\\)*" + "\\)" + "\\|" + "[1-9]\\('[0-9]\\|[0-9]\\)*" + "\\)") + "Regexp matching a numeric literal, including with digit separators.") + +(defun c-quoted-number-straddling-point () + ;; Return non-nil if a definitely quoted number starts before point and ends + ;; after point. In this case the number is bounded by (match-beginning 0) + ;; and (match-end 0). + (when c-has-quoted-numbers + (save-excursion + (let ((here (point)) + (bound (progn (skip-chars-forward "0-9a-fA-F'") (point)))) + (goto-char here) + (when (< (skip-chars-backward "0-9a-fA-F'") 0) + (if (and (memq (char-before) '(?x ?X)) + (eq (char-before (1- (point))) ?0)) + (backward-char 2)) + (while (and (search-forward-regexp c-maybe-quoted-number bound t) + (<= (match-end 0) here))) + (and (< (match-beginning 0) here) + (> (match-end 0) here) + (save-match-data + (goto-char (match-beginning 0)) + (save-excursion (search-forward "'" (match-end 0) t))))))))) + +(defun c-parse-quotes-before-change (beg end) + ;; This function analyzes 's near the region (c-new-BEG c-new-END), amending + ;; those two variables as needed to include 's into that region when they + ;; might be syntactically relevant to the change in progress. ;; - ;; In both uses of the function, the `syntax-table' properties are - ;; removed/applied only on quote marks which appear to be digit separators. + ;; Having amended that region, the function removes pertinent text + ;; properties (syntax-table properties with value '(1) and c-digit-separator + ;; props with value t) from 's in it. This operation is performed even + ;; within strings and comments. ;; - ;; Point is undefined on both entry and exit to this function, and the - ;; return value has no significance. The function is called solely as a - ;; before-change function (see `c-get-state-before-change-functions') and as - ;; an after change function (see `c-before-font-lock-functions', with the - ;; parameters BEG, END, and (optionally) OLD-LEN being given the standard - ;; values for before/after-change functions. - (c-save-buffer-state ((num-begin c-new-BEG) digit-re try-end) + ;; This function is called exclusively as a before-change function via the + ;; variable `c-get-state-before-change-functions'. + (c-save-buffer-state (p-limit limits found) + ;; Special consideraton for deleting \ from '\''. + (if (and (> end beg) + (eq (char-before end) ?\\) + (<= c-new-END end)) + (setq c-new-END (min (1+ end) (point-max)))) + + ;; Do we have a ' (or something like ',',',',',') within range of + ;; c-new-BEG? + (goto-char c-new-BEG) + (setq p-limit (max (- (point) 2) (point-min))) + (while (and (skip-chars-backward "^\\\\'" p-limit) + (> (point) p-limit)) + (when (eq (char-before) ?\\) + (setq p-limit (max (1- p-limit) (point-min)))) + (backward-char) + (setq c-new-BEG (point))) + (beginning-of-line) + (while (and + (setq found (search-forward-regexp "\\('\\([^'\\]\\|\\\\.\\)\\)*'" + c-new-BEG 'limit)) + (< (point) (1- c-new-BEG)))) + (if found + (setq c-new-BEG + (if (and (eq (point) (1- c-new-BEG)) + (eq (char-after) ?')) ; "''" before c-new-BEG. + (1- c-new-BEG) + (match-beginning 0)))) + + ;; Check for a number with quote separators straddling c-new-BEG + (when c-has-quoted-numbers + (goto-char c-new-BEG) + (when ;; (c-quoted-number-straddling-point) + (c-quoted-number-head-before-point) + (setq c-new-BEG (match-beginning 0)))) + + ;; Do we have a ' (or something like ',',',',...,',') within range of + ;; c-new-END? (goto-char c-new-END) - (when (looking-at "\\(x\\)?[0-9a-fA-F']+") - (setq c-new-END (match-end 0))) + (setq p-limit (min (+ (point) 2) (point-max))) + (while (and (skip-chars-forward "^\\\\'" p-limit) + (< (point) p-limit)) + (when (eq (char-after) ?\\) + (setq p-limit (min (1+ p-limit) (point-max)))) + (forward-char) + (setq c-new-END (point))) + (if (looking-at "[^']?\\('\\([^'\\]\\|\\\\.\\)\\)*'") + (setq c-new-END (match-end 0))) + + ;; Check for a number with quote separators straddling c-new-END. + (when c-has-quoted-numbers + (goto-char c-new-END) + (when ;; (c-quoted-number-straddling-point) + (c-quoted-number-tail-after-point) + (setq c-new-END (match-end 0)))) + + ;; Remove the '(1) syntax-table property from all "'"s within (c-new-BEG + ;; c-new-END). + (c-clear-char-property-with-value-on-char + c-new-BEG c-new-END + 'syntax-table '(1) + ?') + ;; Remove the c-digit-separator text property from the same "'"s. + (when c-has-quoted-numbers + (c-clear-char-property-with-value-on-char + c-new-BEG c-new-END + 'c-digit-separator t + ?')))) + +(defun c-parse-quotes-after-change (beg end old-len) + ;; This function applies syntax-table properties (value '(1)) and + ;; c-digit-separator properties as needed to 's within the range (c-new-BEG + ;; c-new-END). This operation is performed even within strings and + ;; comments. + ;; + ;; This function is called exclusively as an after-change function via the + ;; variable `c-before-font-lock-functions'. + (c-save-buffer-state (p-limit limits num-beg num-end clear-from-BEG-to) + ;; Apply the needed syntax-table and c-digit-separator text properties to + ;; quotes. (goto-char c-new-BEG) - (when (looking-at "\\(x?\\)[0-9a-fA-F']") - (if (re-search-backward "\\(0x\\)?[0-9a-fA-F]*\\=" nil t) - (setq c-new-BEG (point)))) - - (while - (re-search-forward "[0-9a-fA-F]'[0-9a-fA-F]" c-new-END t) - (setq try-end (1- (point))) - (re-search-backward "[^0-9a-fA-F']" num-begin t) - (setq digit-re - (cond - ((and (not (bobp)) (eq (char-before) ?0) (memq (char-after) '(?x ?X))) - "[0-9a-fA-F]") - ((and (eq (char-after (1+ (point))) ?0) - (memq (char-after (+ 2 (point))) '(?b ?B))) - "[01]") - ((memq (char-after (1+ (point))) '(?0 ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9)) - "[0-9]") - (t nil))) - (when digit-re - (cond ((eq (char-after) ?x) (forward-char)) - ((looking-at ".?0[Bb]") (goto-char (match-end 0))) - ((looking-at digit-re)) - (t (forward-char))) - (when (not (c-in-literal)) - (let ((num-end ; End of valid sequence of digits/quotes. - (save-excursion - (re-search-forward - (concat "\\=\\(" digit-re "+'\\)*" digit-re "+") nil t) - (point)))) - (setq try-end ; End of sequence of digits/quotes + (while (and (< (point) c-new-END) + (search-forward "'" c-new-END 'limit)) + (cond ((and (eq (char-before (1- (point))) ?\\) + ;; Check we've got an odd number of \s, here. (save-excursion - (re-search-forward - (concat "\\=\\(" digit-re "\\|'\\)+") nil t) - (point))) - (while (re-search-forward - (concat digit-re "\\('\\)" digit-re) num-end t) - (if old-len ; i.e. are we in an after-change function? - (c-put-char-property (match-beginning 1) 'syntax-table '(1)) - (c-clear-char-property (match-beginning 1) 'syntax-table)) - (backward-char))))) - (goto-char try-end) - (setq num-begin (point))))) - -;; The following doesn't seem needed at the moment (2016-08-15). -;; (defun c-before-after-change-extend-region-for-lambda-capture -;; (_beg _end &optional _old-len) -;; ;; In C++ Mode, extend the region (c-new-BEG c-new-END) to cover any lambda -;; ;; function capture lists we happen to be inside. This function is expected -;; ;; to be called both as a before-change and after change function. -;; ;; -;; ;; Note that these things _might_ be nested, with a capture list looking -;; ;; like: -;; ;; -;; ;; [ ...., &foo = [..](){...}(..), ... ] -;; ;; -;; ;; . What a wonderful language is C++. ;-) -;; (c-save-buffer-state (paren-state pos) -;; (goto-char c-new-BEG) -;; (setq paren-state (c-parse-state)) -;; (while (setq pos (c-pull-open-brace paren-state)) -;; (goto-char pos) -;; (when (c-looking-at-c++-lambda-capture-list) -;; (setq c-new-BEG (min c-new-BEG pos)) -;; (if (c-go-list-forward) -;; (setq c-new-END (max c-new-END (point)))))) - -;; (goto-char c-new-END) -;; (setq paren-state (c-parse-state)) -;; (while (setq pos (c-pull-open-brace paren-state)) -;; (goto-char pos) -;; (when (c-looking-at-c++-lambda-capture-list) -;; (setq c-new-BEG (min c-new-BEG pos)) -;; (if (c-go-list-forward) -;; (setq c-new-END (max c-new-END (point)))))))) + (backward-char) + (eq (logand (skip-chars-backward "\\\\") 1) 1)))) ; not a real '. + ((c-quoted-number-straddling-point) + (setq num-beg (match-beginning 0) + num-end (match-end 0)) + (c-put-char-properties-on-char num-beg num-end + 'syntax-table '(1) ?') + (c-put-char-properties-on-char num-beg num-end + 'c-digit-separator t ?') + (goto-char num-end)) + ((looking-at "\\([^\\']\\|\\\\.\\)'") ; balanced quoted expression. + (goto-char (match-end 0))) + (t (c-put-char-property (1- (point)) 'syntax-table '(1))))))) (defun c-before-change (beg end) ;; Function to be put on `before-change-functions'. Primarily, this calls |