code.delx.au - gnu-emacs/blob - lisp/progmodes/cwarn.el

   1 ;;; cwarn.el --- highlight suspicious C and C++ constructions
   2
   3 ;; Copyright (C) 1999-2012  Free Software Foundation, Inc.
   4
   5 ;; Author: Anders Lindgren <andersl@andersl.com>
   6 ;; Keywords: c, languages, faces
   7 ;; X-Url: http://www.andersl.com/emacs
   8 ;; Version: 1.3.1
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software: you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation, either version 3 of the License, or
  15 ;; (at your option) any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  24
  25 ;;; Commentary:
  26
  27 ;;{{{ Documentation
  28
  29 ;; Description:
  30 ;;
  31 ;; CWarn is a package that highlights suspicious C and C++ constructions.
  32 ;;
  33 ;; For example, take a look at the following piece of C code:
  34 ;;
  35 ;;     if (x = 0);
  36 ;;       foo();
  37 ;;
  38 ;; The code contains two, possibly fatal, bugs.  The first is that the
  39 ;; assignment operator "=" is used as part of the test; the user
  40 ;; probably meant to use the comparison operator "==".
  41 ;;
  42 ;; The second problem is that an extra semicolon is placed after
  43 ;; closing parenthesis of the test expression.  This makes the body of
  44 ;; the if statement to be an empty statement, not the call to the
  45 ;; function "foo", as the user probably intended.
  46 ;;
  47 ;; This package is capable of highlighting the following C and C++
  48 ;; constructions:
  49 ;;
  50 ;; * Assignments inside expressions, including variations like "+=".
  51 ;; * Semicolon following immediately after `if', `for', and `while'
  52 ;;   (except, of course, after a `do .. while' statement).
  53 ;; * C++ functions with reference parameters.
  54 ;;
  55 ;; Note that none of the constructions highlighted (especially not C++
  56 ;; reference parameters) are considered errors by the language
  57 ;; definitions.
  58
  59 ;; Usage:
  60 ;;
  61 ;; CWarn is implemented as two minor modes: `cwarn-mode' and
  62 ;; `global-cwarn-mode'.  The former can be applied to individual buffers
  63 ;; and the latter to all buffers.
  64 ;;
  65 ;; Activate this package by Customize, or by placing the following line
  66 ;; into the appropriate init file:
  67 ;;
  68 ;;    (global-cwarn-mode 1)
  69 ;;
  70 ;; Also, `font-lock-mode' or `global-font-lock-mode' must be enabled.
  71
  72 ;; Afterthought:
  73 ;;
  74 ;; After using this package for several weeks it feels as though I
  75 ;; find stupid typo-style bugs while editing rather than at compile-
  76 ;; or run-time, if I ever find them.
  77 ;;
  78 ;; On the other hand, I find myself using assignments inside
  79 ;; expressions much more often than I used to do.  The reason is that
  80 ;; there is no risk of interpreting an assignment operator as a
  81 ;; comparison ("hey, the assignment operator is red, duh!").
  82
  83 ;; Reporting bugs:
  84 ;;
  85 ;;     Out of the last ten bugs you found, how many did you report?
  86 ;;
  87 ;; When reporting a bug, please:
  88 ;;
  89 ;; * Send a mail the maintainer of the package, or to the author
  90 ;;   if no maintainer exists.
  91 ;; * Include the name of the package in the title of the mail, to
  92 ;;   simplify for the recipient.
  93 ;; * State exactly what you did, what happened, and what you expected
  94 ;;   to see when you found the bug.
  95 ;; * If the bug cause an error, set the variable `debug-on-error' to t,
  96 ;;   repeat the operations that triggered the error and include
  97 ;;   the backtrace in the letter.
  98 ;; * If possible, include an example that activates the bug.
  99 ;; * Should you speculate about the cause of the problem, please
 100 ;;   state explicitly that you are guessing.
 101
 102 ;;}}}
 103
 104 ;;; Code:
 105
 106 ;;{{{ Dependencies
 107
 108 (eval-when-compile (require 'cl))
 109
 110 (require 'custom)
 111 (require 'font-lock)
 112 (require 'cc-mode)
 113
 114 ;;}}}
 115 ;;{{{ Variables
 116
 117 (defgroup cwarn nil
 118   "Highlight suspicious C and C++ constructions."
 119   :version "21.1"
 120   :link '(url-link "http://www.andersl.com/emacs")
 121   :group 'faces)
 122
 123 (defvar cwarn-mode nil
 124   "*Non-nil when Cwarn mode is active.
 125
 126 Never set this variable directly, use the command `cwarn-mode'
 127 instead.")
 128
 129 (defcustom cwarn-configuration
 130   '((c-mode (not reference))
 131     (c++-mode t))
 132   "*List of items each describing which features are enable for a mode.
 133 Each item is on the form (mode featurelist), where featurelist can be
 134 on one of three forms:
 135
 136 * A list of enabled features.
 137 * A list starting with the atom `not' followed by the features
 138   which are not enabled.
 139 * The atom t, that represent that all features are enabled.
 140
 141 See variable `cwarn-font-lock-feature-keywords-alist' for available
 142 features."
 143   :type '(repeat sexp)
 144   :group 'cwarn)
 145
 146 (defcustom cwarn-font-lock-feature-keywords-alist
 147   '((assign    . cwarn-font-lock-assignment-keywords)
 148     (semicolon . cwarn-font-lock-semicolon-keywords)
 149     (reference . cwarn-font-lock-reference-keywords))
 150   "An alist mapping a CWarn feature to font-lock keywords.
 151 The keywords could either a font-lock keyword list or a symbol.
 152 If it is a symbol it is assumed to be a variable containing a font-lock
 153 keyword list."
 154   :type '(alist :key-type (choice (const assign)
 155                                   (const semicolon)
 156                                   (const reference))
 157                 :value-type (sexp :tag "Value"))
 158   :group 'cwarn)
 159
 160 (defcustom cwarn-verbose t
 161   "*When nil, CWarn mode will not generate any messages.
 162
 163 Currently, messages are generated when the mode is activated and
 164 deactivated."
 165   :group 'cwarn
 166   :type 'boolean)
 167
 168 (defcustom cwarn-mode-text " CWarn"
 169   "*String to display in the mode line when CWarn mode is active.
 170
 171 \(When the string is not empty, make sure that it has a leading space.)"
 172   :tag "CWarn mode text"                ; To separate it from `global-...'
 173   :group 'cwarn
 174   :type 'string)
 175
 176 (defcustom cwarn-load-hook nil
 177   "*Functions to run when CWarn mode is first loaded."
 178   :tag "Load Hook"
 179   :group 'cwarn
 180   :type 'hook)
 181
 182 ;;}}}
 183 ;;{{{ The modes
 184
 185 ;;;###autoload
 186 (define-minor-mode cwarn-mode
 187   "Minor mode that highlights suspicious C and C++ constructions.
 188
 189 Suspicious constructs are highlighted using `font-lock-warning-face'.
 190
 191 Note, in addition to enabling this minor mode, the major mode must
 192 be included in the variable `cwarn-configuration'.  By default C and
 193 C++ modes are included.
 194
 195 With ARG, turn CWarn mode on if and only if arg is positive."
 196   :group 'cwarn :lighter cwarn-mode-text
 197   (cwarn-font-lock-keywords cwarn-mode)
 198   (if font-lock-mode (font-lock-fontify-buffer)))
 199
 200 ;;;###autoload
 201 (defun turn-on-cwarn-mode ()
 202   "Turn on CWarn mode.
 203
 204 This function is designed to be added to hooks, for example:
 205   (add-hook 'c-mode-hook 'turn-on-cwarn-mode)"
 206   (cwarn-mode 1))
 207
 208 ;;}}}
 209 ;;{{{ Help functions
 210
 211 (defun cwarn-is-enabled (mode &optional feature)
 212   "Non-nil if CWarn FEATURE is enabled for MODE.
 213 FEATURE is an atom representing one construction to highlight.
 214
 215 Check if any feature is enabled for MODE if no feature is specified.
 216
 217 The valid features are described by the variable
 218 `cwarn-font-lock-feature-keywords-alist'."
 219   (let ((mode-configuration (assq mode cwarn-configuration)))
 220     (and mode-configuration
 221          (or (null feature)
 222              (let ((list-or-t (nth 1 mode-configuration)))
 223                (or (eq list-or-t t)
 224                    (if (eq (car-safe list-or-t) 'not)
 225                        (not (memq feature (cdr list-or-t)))
 226                      (memq feature list-or-t))))))))
 227
 228 (defun cwarn-inside-macro ()
 229   "True if point is inside a C macro definition."
 230   (save-excursion
 231     (beginning-of-line)
 232     (while (eq (char-before (1- (point))) ?\\)
 233       (forward-line -1))
 234     (back-to-indentation)
 235     (eq (char-after) ?#)))
 236
 237 (defun cwarn-font-lock-keywords (addp)
 238   "Install/remove keywords into current buffer.
 239 If ADDP is non-nil, install else remove."
 240   (dolist (pair cwarn-font-lock-feature-keywords-alist)
 241     (let ((feature (car pair))
 242           (keywords (cdr pair)))
 243       (if (not (listp keywords))
 244           (setq keywords (symbol-value keywords)))
 245       (if (cwarn-is-enabled major-mode feature)
 246           (funcall (if addp 'font-lock-add-keywords 'font-lock-remove-keywords)
 247                    nil keywords)))))
 248
 249 ;;}}}
 250 ;;{{{ Backward compatibility
 251
 252 ;; This piece of code will be part of CC mode as of Emacs 20.4.
 253 (if (not (fboundp 'c-at-toplevel-p))
 254 (defun c-at-toplevel-p ()
 255   "Return a determination as to whether point is at the `top-level'.
 256 Being at the top-level means that point is either outside any
 257 enclosing block (such function definition), or inside a class
 258 definition, but outside any method blocks.
 259
 260 If point is not at the top-level (e.g. it is inside a method
 261 definition), then nil is returned.  Otherwise, if point is at a
 262 top-level not enclosed within a class definition, t is returned.
 263 Otherwise, a 2-vector is returned where the zeroth element is the
 264 buffer position of the start of the class declaration, and the first
 265 element is the buffer position of the enclosing class' opening
 266 brace."
 267   (let ((state (c-parse-state)))
 268     (or (not (c-most-enclosing-brace state))
 269         (c-search-uplist-for-classkey state))))
 270 )
 271
 272 ;;}}}
 273 ;;{{{ Font-lock keywords and match functions
 274
 275 ;; This section contains font-lock keywords.  A font lock keyword can
 276 ;; either contain a regular expression or a match function.  All
 277 ;; keywords defined here use match functions since the C and C++
 278 ;; constructions highlighted by CWarn are too complex to be matched by
 279 ;; regular expressions.
 280 ;;
 281 ;; A match function should act like a normal forward search.  They
 282 ;; should return non-nil if they found a candidate and the match data
 283 ;; should correspond to the highlight part of the font-lock keyword.
 284 ;; The functions should not generate errors, in that case font-lock
 285 ;; will fail to highlight the buffer.  A match function takes one
 286 ;; argument, LIMIT, that represent the end of area to be searched.
 287 ;;
 288 ;; The variable `cwarn-font-lock-feature-keywords-alist' contains a
 289 ;; mapping from CWarn features to the font-lock keywords defined
 290 ;; below.
 291
 292 (defmacro cwarn-font-lock-match (re &rest body)
 293   "Match RE but only if BODY holds."
 294   `(let ((res nil))
 295      (while
 296          (progn
 297            (setq res (re-search-forward ,re limit t))
 298            (and res
 299                 (save-excursion
 300                   (when (match-beginning 1) (goto-char (match-beginning 1)))
 301                   (condition-case nil   ; In case something barfs.
 302                       (not (save-match-data
 303                              ,@body))
 304                     (error t))))))
 305      res))
 306
 307 ;;{{{ Assignment in expressions
 308
 309 (defconst cwarn-font-lock-assignment-keywords
 310   '((cwarn-font-lock-match-assignment-in-expression
 311      (1 font-lock-warning-face))))
 312
 313 (defun cwarn-font-lock-match-assignment-in-expression (limit)
 314   "Match assignments inside expressions."
 315   (cwarn-font-lock-match
 316    "[^!<>=]\\(\\([-+*/%&^|]\\|<<\\|>>\\)?=\\)[^=]"
 317    (backward-up-list 1)
 318    (and (memq (following-char) '(?\( ?\[))
 319         (not (progn
 320                (skip-chars-backward " ")
 321                (skip-chars-backward "a-zA-Z0-9_")
 322                (or
 323                 ;; Default parameter of function.
 324                 (c-at-toplevel-p)
 325                 (looking-at "for\\>")))))))
 326
 327 ;;}}}
 328 ;;{{{ Semicolon
 329
 330 (defconst cwarn-font-lock-semicolon-keywords
 331   '((cwarn-font-lock-match-dangerous-semicolon (0 font-lock-warning-face))))
 332
 333 (defun cwarn-font-lock-match-dangerous-semicolon (limit)
 334   "Match semicolons directly after `for', `while', and `if'.
 335 The semicolon after a `do { ... } while (x);' construction is not matched."
 336   (cwarn-font-lock-match
 337    ";"
 338    (backward-sexp 2)                    ; Expression and keyword.
 339    (or (looking-at "\\(for\\|if\\)\\>")
 340        (and (looking-at "while\\>")
 341             (condition-case nil
 342                 (progn
 343                   (backward-sexp 2)     ; Body and "do".
 344                   (not (looking-at "do\\>")))
 345               (error t))))))
 346
 347 ;;}}}
 348 ;;{{{ Reference
 349
 350 (defconst cwarn-font-lock-reference-keywords
 351   '((cwarn-font-lock-match-reference (1 font-lock-warning-face))))
 352
 353 (defun cwarn-font-lock-match-reference (limit)
 354   "Font-lock matcher for C++ reference parameters."
 355   (cwarn-font-lock-match
 356    "[^&]\\(&\\)[^&=]"
 357    (backward-up-list 1)
 358    (and (eq (following-char) ?\()
 359         (not (cwarn-inside-macro))
 360         (c-at-toplevel-p))))
 361
 362 ;;}}}
 363
 364 ;;}}}
 365 ;;{{{ The end
 366
 367 (defun turn-on-cwarn-mode-if-enabled ()
 368   "Turn on CWarn mode in the current buffer if applicable.
 369 The mode is turned if some feature is enabled for the current
 370 `major-mode' in `cwarn-configuration'."
 371   (if (cwarn-is-enabled major-mode) (turn-on-cwarn-mode)))
 372
 373 ;;;###autoload
 374 (define-globalized-minor-mode global-cwarn-mode
 375   cwarn-mode turn-on-cwarn-mode-if-enabled)
 376
 377 (provide 'cwarn)
 378
 379 (run-hooks 'cwarn-load-hook)
 380
 381 ;;}}}
 382
 383 ;;; cwarn.el ends here