7 files changed, 387 insertions, 449 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 12f0f5e3218..998fa13bbba 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,45 @@
+2014-09-10  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        CC-mode: Set open-paren-in-column-0-is-defun-start to nil;
+        plus misc cleanup.
+        * progmodes/cc-mode.el (c-basic-common-init):
+        Set open-paren-in-column-0-is-defun-start.
+        (adaptive-fill-first-line-regexp, font-lock-syntactic-keywords):
+        Remove declarations, unused.
+        (run-mode-hooks): Remove declaration.
+        (font-lock-defaults): Use plain `defvar' to declare.
+        (c-run-mode-hooks): Test existence of run-mode-hooks with fboundp.
+        * progmodes/cc-langs.el (c-filter-ops): Avoid `setq'.
+        (c-make-mode-syntax-table): Don't micro-optimize.
+        (c-keywords, c-keyword-member-alist): Simplify.
+        (c-kwds-lang-consts): Don't eval at compile-time.
+        (c-primary-expr-regexp): Comment out unused vars.
+        * progmodes/cc-fonts.el (c-font-lock-context): Declare at top-level.
+        (c-font-byte-compile): New var.
+        (c--compile): New function.  Use it instead of `byte-compile'.
+        (c-cpp-matchers): Quote the value returned by
+        `c-make-syntactic-matcher' in case it's not self-evaluating.
+        (c-basic-matchers-before): Avoid a plain MATCHER as keyword, wrap it in
+        parentheses instead (in case MATCHER happens to be a list).
+        (c-font-lock-enum-tail): Remove unused var `start'.
+        (c-font-lock-objc-methods): Silence byte-compiler warnings.
+        * progmodes/cc-engine.el (c-syntactic-re-search-forward): Sink an `if'
+        test into an argument.
+        * progmodes/cc-defs.el (c-point, c-major-mode-is, c-put-char-property)
+        (c-get-char-property): Don't use `eval' just to unquote a constant.
+        (c-use-extents): Remove.  Use (featurep 'xemacs), compiled
+        more efficiently.
+        (c-put-char-property-fun): Don't call `byte-compile' by hand.
+        (c-clear-char-property, c-clear-char-properties): Check that `property'
+        is a quoted constant.
+        (c-emacs-features): Remove `infodock', `syntax-properties', and
+        `pps-extended-state' (never used), `8-bit' and `1-bit' (use (featurep
+        'xemacs) instead).  Use `with-temp-buffer' and let-bind vars after
+        changing buffer, so we don't have to setq them again afterwards.
+        (c-lang-const): Remove redundant symbolp assertions.
+        (c-find-assignment-for-mode): Use `or'.
+        * Makefile.in (compile-one-process): Remove cc-mode dependency.
+
 2014-09-09  Sam Steingold  <sds@gnu.org>
 
         * progmodes/sql.el (sql-default-directory): Fix type annotation.
diff --git a/lisp/Makefile.in b/lisp/Makefile.in
index 258cc3b8ae1..5733ea52715 100644
--- a/lisp/Makefile.in
+++ b/lisp/Makefile.in
@@ -387,7 +387,7 @@ compile-after-backup: backup-compiled-files compile-always
 # There is no reason to use this rule unless you only have a single
 # core and CPU time is an issue.
 .PHONY: compile-one-process
-compile-one-process: $(LOADDEFS) compile-first $(lisp)/progmodes/cc-mode.elc
+compile-one-process: $(LOADDEFS) compile-first
         $(emacs) $(BYTE_COMPILE_FLAGS) \
             --eval "(batch-byte-recompile-directory 0)" $(lisp)
 
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index 5d528caabb2..91c5773ebb4 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -195,7 +195,7 @@ If the referenced position doesn't exist, the closest accessible point
 to it is returned.  This function does not modify the point or the mark."
 
   (if (eq (car-safe position) 'quote)
-      (let ((position (eval position)))
+      (let ((position (nth 1 position)))
         (cond
 
          ((eq position 'bol)
@@ -885,7 +885,7 @@ MODE is either a mode symbol or a list of mode symbols."
       `(c-lang-major-mode-is ,mode)
 
     (if (eq (car-safe mode) 'quote)
-        (let ((mode (eval mode)))
+        (let ((mode (nth 1 mode)))
           (if (listp mode)
               `(memq c-buffer-is-cc-mode ',mode)
             `(eq c-buffer-is-cc-mode ',mode)))
@@ -900,26 +900,10 @@ MODE is either a mode symbol or a list of mode symbols."
 ;; properties set on a single character and that never spread to any
 ;; other characters.
 
-(eval-and-compile
-  ;; Constant used at compile time to decide whether or not to use
-  ;; XEmacs extents.  Check all the extent functions we'll use since
-  ;; some packages might add compatibility aliases for some of them in
-  ;; Emacs.
-  (defconst c-use-extents (and (cc-bytecomp-fboundp 'extent-at)
-                               (cc-bytecomp-fboundp 'set-extent-property)
-                               (cc-bytecomp-fboundp 'set-extent-properties)
-                               (cc-bytecomp-fboundp 'make-extent)
-                               (cc-bytecomp-fboundp 'extent-property)
-                               (cc-bytecomp-fboundp 'delete-extent)
-                               (cc-bytecomp-fboundp 'map-extents))))
-
 ;; `c-put-char-property' is complex enough in XEmacs and Emacs < 21 to
 ;; make it a function.
 (defalias 'c-put-char-property-fun
-  (cc-eval-when-compile
-    (cond (c-use-extents
-           ;; XEmacs.
-           (byte-compile
+  (cond ((featurep 'xemacs)
             (lambda (pos property value)
               (let ((ext (extent-at pos nil property)))
                 (if ext
@@ -928,20 +912,19 @@ MODE is either a mode symbol or a list of mode symbols."
                                          (cons property
                                                (cons value
                                                      '(start-open t
-                                                       end-open t)))))))))
+                                                    end-open t))))))))
 
           ((not (cc-bytecomp-boundp 'text-property-default-nonsticky))
            ;; In Emacs < 21 we have to mess with the `rear-nonsticky' property.
-           (byte-compile
             (lambda (pos property value)
               (put-text-property pos (1+ pos) property value)
               (let ((prop (get-text-property pos 'rear-nonsticky)))
                 (or (memq property prop)
                     (put-text-property pos (1+ pos)
                                        'rear-nonsticky
-                                       (cons property prop)))))))
+                                    (cons property prop))))))
           ;; This won't be used for anything.
-          (t 'ignore))))
+        (t #'ignore)))
 (cc-bytecomp-defun c-put-char-property-fun) ; Make it known below.
 
 (defmacro c-put-char-property (pos property value)
@@ -956,42 +939,38 @@ MODE is either a mode symbol or a list of mode symbols."
   ;; 21) then it's assumed that the property is present on it.
   ;;
   ;; This macro does a hidden buffer change.
-  (setq property (eval property))
-  (if (or c-use-extents
+  (if (or (featurep 'xemacs)
           (not (cc-bytecomp-boundp 'text-property-default-nonsticky)))
       ;; XEmacs and Emacs < 21.
-      `(c-put-char-property-fun ,pos ',property ,value)
+      `(c-put-char-property-fun ,pos ,property ,value)
     ;; In Emacs 21 we got the `rear-nonsticky' property covered
     ;; by `text-property-default-nonsticky'.
     `(let ((-pos- ,pos))
-       (put-text-property -pos- (1+ -pos-) ',property ,value))))
+       (put-text-property -pos- (1+ -pos-) ,property ,value))))
 
 (defmacro c-get-char-property (pos property)
   ;; Get the value of the given property on the character at POS if
   ;; it's been put there by `c-put-char-property'.  PROPERTY is
   ;; assumed to be constant.
-  (setq property (eval property))
-  (if c-use-extents
+  (if (featurep 'xemacs)
       ;; XEmacs.
-      `(let ((ext (extent-at ,pos nil ',property)))
-         (if ext (extent-property ext ',property)))
+      `(let ((ext (extent-at ,pos nil ,property)))
+         (if ext (extent-property ext ,property)))
     ;; Emacs.
-    `(get-text-property ,pos ',property)))
+    `(get-text-property ,pos ,property)))
 
 ;; `c-clear-char-property' is complex enough in Emacs < 21 to make it
 ;; a function, since we have to mess with the `rear-nonsticky' property.
 (defalias 'c-clear-char-property-fun
-  (cc-eval-when-compile
-    (unless (or c-use-extents
+  (unless (or (featurep 'xemacs)
                 (cc-bytecomp-boundp 'text-property-default-nonsticky))
-      (byte-compile
        (lambda (pos property)
          (when (get-text-property pos property)
            (remove-text-properties pos (1+ pos) (list property nil))
            (put-text-property pos (1+ pos)
                               'rear-nonsticky
                               (delq property (get-text-property
-                                              pos 'rear-nonsticky)))))))))
+                                           pos 'rear-nonsticky)))))))
 (cc-bytecomp-defun c-clear-char-property-fun) ; Make it known below.
 
 (defmacro c-clear-char-property (pos property)
@@ -1000,8 +979,10 @@ MODE is either a mode symbol or a list of mode symbols."
   ;; constant.
   ;;
   ;; This macro does a hidden buffer change.
-  (setq property (eval property))
-  (cond (c-use-extents
+  (if (eq 'quote (car-safe property))
+      (setq property (nth 1 property))
+    (error "`property' should be a quoted constant"))
+  (cond ((featurep 'xemacs)
          ;; XEmacs.
          `(let ((ext (extent-at ,pos nil ',property)))
             (if ext (delete-extent ext))))
@@ -1026,8 +1007,10 @@ MODE is either a mode symbol or a list of mode symbols."
   ;; `syntax-table'.
   ;;
   ;; This macro does hidden buffer changes.
-  (setq property (eval property))
-  (if c-use-extents
+  (if (eq 'quote (car-safe property))
+      (setq property (nth 1 property))
+    (error "`property' should be a quoted constant"))
+  (if (featurep 'xemacs)
       ;; XEmacs.
       `(map-extents (lambda (ext ignored)
                       (delete-extent ext))
@@ -1097,7 +1080,7 @@ been put there by c-put-char-property.  POINT remains unchanged."
 which have the value VALUE, 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
+  (if (featurep 'xemacs)
     ;; XEmacs
       `(let ((-property- ,property))
          (map-extents (lambda (ext val)
@@ -1561,32 +1544,6 @@ non-nil, a caret is prepended to invert the set."
 (defconst c-emacs-features
   (let (list)
 
-    (if (boundp 'infodock-version)
-        ;; I've no idea what this actually is, but it's legacy. /mast
-        (setq list (cons 'infodock list)))
-
-    ;; XEmacs uses 8-bit modify-syntax-entry flags.
-    ;; Emacs uses a 1-bit flag.  We will have to set up our
-    ;; syntax tables differently to handle this.
-    (let ((table (copy-syntax-table))
-          entry)
-      (modify-syntax-entry ?a ". 12345678" table)
-      (cond
-       ;; Emacs
-       ((arrayp table)
-        (setq entry (aref table ?a))
-        ;; In Emacs, table entries are cons cells
-        (if (consp entry) (setq entry (car entry))))
-       ;; XEmacs
-       ((fboundp 'get-char-table)
-        (setq entry (get-char-table ?a table)))
-       ;; incompatible
-       (t (error "CC Mode is incompatible with this version of Emacs")))
-      (setq list (cons (if (= (logand (lsh entry -16) 255) 255)
-                           '8-bit
-                         '1-bit)
-                       list)))
-
     ;; Check whether beginning/end-of-defun call
     ;; beginning/end-of-defun-function nicely, passing through the
     ;; argument and respecting the return code.
@@ -1609,35 +1566,12 @@ non-nil, a caret is prepended to invert the set."
                                (not (end-of-defun))))
           (setq list (cons 'argumentative-bod-function list))))
 
-    (let ((buf (generate-new-buffer " test"))
-          parse-sexp-lookup-properties
-          parse-sexp-ignore-comments
-          lookup-syntax-properties)     ; XEmacs
-      (with-current-buffer buf
+    (with-temp-buffer
+      (let ((parse-sexp-lookup-properties t)
+            (parse-sexp-ignore-comments t)
+            (lookup-syntax-properties t))       ; XEmacs
         (set-syntax-table (make-syntax-table))
 
-        ;; For some reason we have to set some of these after the
-        ;; buffer has been made current.  (Specifically,
-        ;; `parse-sexp-ignore-comments' in Emacs 21.)
-        (setq parse-sexp-lookup-properties t
-              parse-sexp-ignore-comments t
-              lookup-syntax-properties t)
-
-        ;; Find out if the `syntax-table' text property works.
-        (modify-syntax-entry ?< ".")
-        (modify-syntax-entry ?> ".")
-        (insert "<()>")
-        (c-mark-<-as-paren (point-min))
-        (c-mark->-as-paren (+ 3 (point-min)))
-        (goto-char (point-min))
-        (c-forward-sexp)
-        (if (= (point) (+ 4 (point-min)))
-            (setq list (cons 'syntax-properties list))
-          (error (concat
-                  "CC Mode is incompatible with this version of Emacs - "
-                  "support for the `syntax-table' text property "
-                  "is required.")))
-
         ;; Find out if generic comment delimiters work.
         (c-safe
           (modify-syntax-entry ?x "!")
@@ -1674,11 +1608,11 @@ non-nil, a caret is prepended to invert the set."
             (cond
              ;; XEmacs.  Afaik this is currently an Emacs-only
              ;; feature, but it's good to be prepared.
-             ((memq '8-bit list)
+             ((featurep 'xemacs)
               (modify-syntax-entry ?/ ". 1456")
               (modify-syntax-entry ?* ". 23"))
              ;; Emacs
-             ((memq '1-bit list)
+             (t
               (modify-syntax-entry ?/ ". 124b")
               (modify-syntax-entry ?* ". 23")))
             (modify-syntax-entry ?\n "> b")
@@ -1687,16 +1621,7 @@ non-nil, a caret is prepended to invert the set."
             (if (bobp)
                 (setq list (cons 'col-0-paren list)))))
 
-        (set-buffer-modified-p nil))
-      (kill-buffer buf))
-
-    ;; See if `parse-partial-sexp' returns the eighth element.
-    (if (c-safe (>= (length (save-excursion (parse-partial-sexp (point) (point))))
-                    10))
-        (setq list (cons 'pps-extended-state list))
-      (error (concat
-              "CC Mode is incompatible with this version of Emacs - "
-              "`parse-partial-sexp' has to return at least 10 elements.")))
+        (set-buffer-modified-p nil)))
 
     ;;(message "c-emacs-features: %S" list)
     list)
@@ -1705,29 +1630,16 @@ There are many flavors of Emacs out there, each with different
 features supporting those needed by CC Mode.  The following values
 might be present:
 
-'8-bit              8 bit syntax entry flags (XEmacs style).
-'1-bit              1 bit syntax entry flags (Emacs style).
-'argumentative-bod-function         beginning-of-defun passes ARG through
-                    to a non-null beginning-of-defun-function.  It is assumed
-                    the end-of-defun does the same thing.
-'syntax-properties  It works to override the syntax for specific characters
-                    in the buffer with the 'syntax-table property.  It's
-                    always set - CC Mode no longer works in emacsen without
-                    this feature.
-'gen-comment-delim  Generic comment delimiters work
+`argumentative-bod-function'         `beginning-of-defun' passes ARG through
+                    to a non-null `beginning-of-defun-function.'  It is assumed
+                    that `end-of-defun' does the same thing.
+`gen-comment-delim'  Generic comment delimiters work
                     (i.e. the syntax class `!').
-'gen-string-delim   Generic string delimiters work
+`gen-string-delim'   Generic string delimiters work
                     (i.e. the syntax class `|').
-'pps-extended-state `parse-partial-sexp' returns a list with at least 10
-                    elements, i.e. it contains the position of the start of
-                    the last comment or string.  It's always set - CC Mode
-                    no longer works in emacsen without this feature.
-'posix-char-classes The regexp engine understands POSIX character classes.
-'col-0-paren        It's possible to turn off the ad-hoc rule that a paren
-                    in column zero is the start of a defun.
-'infodock           This is Infodock (based on XEmacs).
-
-'8-bit and '1-bit are mutually exclusive.")
+`posix-char-classes' The regexp engine understands POSIX character classes.
+`col-0-paren'        It's possible to turn off the ad-hoc rule that a paren
+                    in column zero is the start of a defun.")
 
 
 ;;; Some helper constants.
@@ -2023,11 +1935,6 @@ LANG is the name of the language, i.e. the mode name without the
 language.  NAME and LANG are not evaluated so they should not be
 quoted."
 
-  (or (symbolp name)
-      (error "Not a symbol: %S" name))
-  (or (symbolp lang)
-      (error "Not a symbol: %S" lang))
-
   (let ((sym (intern (symbol-name name) c-lang-constants))
         (mode (when lang (intern (concat (symbol-name lang) "-mode")))))
 
@@ -2188,57 +2095,56 @@ fallback definition for all modes, to break the cycle).")
         value))))
 
 (defun c-find-assignment-for-mode (source-pos mode match-any-lang _name)
-  ;; Find the first assignment entry that applies to MODE at or after
-  ;; SOURCE-POS.  If MATCH-ANY-LANG is non-nil, entries with `t' as
-  ;; the language list are considered to match, otherwise they don't.
-  ;; On return SOURCE-POS is updated to point to the next assignment
-  ;; after the returned one.  If no assignment is found,
-  ;; `c-lang--novalue' is returned as a magic value.
-  ;;
-  ;; SOURCE-POS is a vector that points out a specific assignment in
-  ;; the double alist that's used in the `source' property.  The first
-  ;; element is the position in the top alist which is indexed with
-  ;; the source files, and the second element is the position in the
-  ;; nested bindings alist.
-  ;;
-  ;; NAME is only used for error messages.
+  "Find the first assignment entry that applies to MODE at or after
+SOURCE-POS.  If MATCH-ANY-LANG is non-nil, entries with `t' as
+the language list are considered to match, otherwise they don't.
+On return SOURCE-POS is updated to point to the next assignment
+after the returned one.  If no assignment is found,
+`c-lang--novalue' is returned as a magic value.
+
+SOURCE-POS is a vector that points out a specific assignment in
+the double alist that's used in the `source' property.  The first
+element is the position in the top alist which is indexed with
+the source files, and the second element is the position in the
+nested bindings alist.
+
+NAME is only used for error messages."
 
   (catch 'found
     (let ((file-entry (elt source-pos 0))
           (assignment-entry (elt source-pos 1))
           assignment)
 
-      (while (if assignment-entry
-                 t
-               ;; Handled the last assignment from one file, begin on the
-               ;; next.  Due to the check in `c-lang-defconst', we know
-               ;; there's at least one.
-               (when file-entry
-
-                 (unless (aset source-pos 1
-                               (setq assignment-entry (cdar file-entry)))
-                   ;; The file containing the source definitions has not
-                   ;; been loaded.
-                   (let ((file (symbol-name (caar file-entry)))
-                         (c-lang-constants-under-evaluation nil))
-                     ;;(message (concat "Loading %s to get the source "
-                     ;;                 "value for language constant %s")
-                     ;;         file name)
-                     (load file nil t))
-
-                   (unless (setq assignment-entry (cdar file-entry))
-                     ;; The load didn't fill in the source for the
-                     ;; constant as expected.  The situation is
-                     ;; probably that a derived mode was written for
-                     ;; and compiled with another version of CC Mode,
-                     ;; and the requested constant isn't in the
-                     ;; currently loaded one.  Put in a dummy
-                     ;; assignment that matches no language.
-                     (setcdr (car file-entry)
-                             (setq assignment-entry (list (list nil))))))
-
-                 (aset source-pos 0 (setq file-entry (cdr file-entry)))
-                 t))
+      (while (or assignment-entry
+                 ;; Handled the last assignment from one file, begin on the
+                 ;; next.  Due to the check in `c-lang-defconst', we know
+                 ;; there's at least one.
+                 (when file-entry
+
+                   (unless (aset source-pos 1
+                                 (setq assignment-entry (cdar file-entry)))
+                     ;; The file containing the source definitions has not
+                     ;; been loaded.
+                     (let ((file (symbol-name (caar file-entry)))
+                           (c-lang-constants-under-evaluation nil))
+                       ;;(message (concat "Loading %s to get the source "
+                       ;;                       "value for language constant %s")
+                       ;;               file name)
+                       (load file nil t))
+
+                     (unless (setq assignment-entry (cdar file-entry))
+                       ;; The load didn't fill in the source for the
+                       ;; constant as expected.  The situation is
+                       ;; probably that a derived mode was written for
+                       ;; and compiled with another version of CC Mode,
+                       ;; and the requested constant isn't in the
+                       ;; currently loaded one.  Put in a dummy
+                       ;; assignment that matches no language.
+                       (setcdr (car file-entry)
+                               (setq assignment-entry (list (list nil))))))
+
+                   (aset source-pos 0 (setq file-entry (cdr file-entry)))
+                   t))
 
         (setq assignment (car assignment-entry))
         (aset source-pos 1
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 9eb95f69c48..ce7797b411a 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -2222,6 +2222,8 @@ comment at the start of cc-engine.el for more info."
        ((and (not not-in-delimiter)     ; inside a comment starter
              (not (bobp))
              (progn (backward-char)
+                    ;; FIXME: We never add category-properties to
+                    ;; c-emacs-features!
                     (and (not (and (memq 'category-properties c-emacs-features)
                                    (looking-at "\\s!")))
                          (looking-at c-comment-start-regexp))))
@@ -4119,10 +4121,10 @@ comment at the start of cc-engine.el for more info."
                                  (c-end-of-current-token last-token-end-pos))
                                (setq last-token-end-pos (point))))))
                  ;; Inside a token.
-                 (if lookbehind-submatch
-                     ;; See the NOTE above.
-                     (goto-char state-pos)
-                   (goto-char (min last-token-end-pos bound))))
+                 (goto-char (if lookbehind-submatch
+                                ;; See the NOTE above.
+                                state-pos
+                              (min last-token-end-pos bound))))
 
                 (t
                  ;; A real match.
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index c056091ca46..329e274e912 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -201,17 +201,18 @@
   :version "24.1"
   :group 'c)
 
+;; This indicates the "font locking context", and is set just before
+;; fontification is done.  If non-nil, it says, e.g., point starts
+;; from within a #if preprocessor construct.
+(defvar c-font-lock-context nil)
+(make-variable-buffer-local 'c-font-lock-context)
+(cc-bytecomp-defvar c-font-lock-context)
+
 (eval-and-compile
   ;; We need the following definitions during compilation since they're
   ;; used when the `c-lang-defconst' initializers are evaluated.  Define
   ;; them at runtime too for the sake of derived modes.
 
-  ;; This indicates the "font locking context", and is set just before
-  ;; fontification is done.  If non-nil, it says, e.g., point starts
-  ;; from within a #if preprocessor construct.
-  (defvar c-font-lock-context nil)
-  (make-variable-buffer-local 'c-font-lock-context)
-
   (defmacro c-put-font-lock-face (from to face)
     ;; Put a face on a region (overriding any existing face) in the way
     ;; font-lock would do it.  In XEmacs that means putting an
@@ -272,18 +273,29 @@
                     (c-got-face-at (point) c-literal-faces))))
       t))
 
+  (defvar c-font-byte-compile t
+    "If non-nil, byte-compile the dynamically-generated functions.")
+
+  (defun c--compile (exp)
+    (cond
+     ((byte-code-function-p exp) (error "Already byte-compiled: %S" exp))
+     ((not (eq (car-safe exp) 'lambda))
+      (error "Expected a (lambda ..): %S" exp))
+     (c-font-byte-compile (byte-compile exp))
+     (t (eval (macroexpand-all exp)))))
+
   (defun c-make-syntactic-matcher (regexp)
-    ;; Returns a byte compiled function suitable for use in place of a
-    ;; regexp string in a `font-lock-keywords' matcher, except that
-    ;; only matches outside comments and string literals count.
-    ;;
-    ;; This function does not do any hidden buffer changes, but the
-    ;; generated functions will.  (They are however used in places
-    ;; covered by the font-lock context.)
-    (byte-compile
+    "Return a function suitable for use in place of a
+regexp string in a `font-lock-keywords' matcher, except that
+only matches outside comments and string literals count.
+
+This function does not do any hidden buffer changes, but the
+generated functions will.  (They are however used in places
+covered by the font-lock context.)"
+    (c--compile
      `(lambda (limit)
         (let (res)
-          (while (and (setq res (re-search-forward ,regexp limit t))
+          (while (and (setq res (re-search-forward ,regexp limit t))
                       (progn
                         (goto-char (match-beginning 0))
                         (or (c-skip-comments-and-strings limit)
@@ -332,34 +344,34 @@
             highlights))))
 
   (defun c-make-font-lock-search-function (regexp &rest highlights)
-    ;; This function makes a byte compiled function that works much like
-    ;; a matcher element in `font-lock-keywords'.  It cuts out a little
-    ;; bit of the overhead compared to a real matcher.  The main reason
-    ;; is however to pass the real search limit to the anchored
-    ;; matcher(s), since most (if not all) font-lock implementations
-    ;; arbitrarily limit anchored matchers to the same line, and also
-    ;; to insulate against various other irritating differences between
-    ;; the different (X)Emacs font-lock packages.
-    ;;
-    ;; REGEXP is the matcher, which must be a regexp.  Only matches
-    ;; where the beginning is outside any comment or string literal are
-    ;; significant.
-    ;;
-    ;; HIGHLIGHTS is a list of highlight specs, just like in
-    ;; `font-lock-keywords', with these limitations: The face is always
-    ;; overridden (no big disadvantage, since hits in comments etc are
-    ;; filtered anyway), there is no "laxmatch", and an anchored matcher
-    ;; is always a form which must do all the fontification directly.
-    ;; `limit' is a variable bound to the real limit in the context of
-    ;; the anchored matcher forms.
-    ;;
-    ;; This function does not do any hidden buffer changes, but the
-    ;; generated functions will.  (They are however used in places
-    ;; covered by the font-lock context.)
-
-    ;; Note: Replace `byte-compile' with `eval' to debug the generated
+    "This function makes a byte compiled function that works much like
+a matcher element in `font-lock-keywords'.  It cuts out a little
+bit of the overhead compared to a real matcher.  The main reason
+is however to pass the real search limit to the anchored
+matcher(s), since most (if not all) font-lock implementations
+arbitrarily limit anchored matchers to the same line, and also
+to insulate against various other irritating differences between
+the different (X)Emacs font-lock packages.
+
+REGEXP is the matcher, which must be a regexp.  Only matches
+where the beginning is outside any comment or string literal are
+significant.
+
+HIGHLIGHTS is a list of highlight specs, just like in
+`font-lock-keywords', with these limitations: The face is always
+overridden (no big disadvantage, since hits in comments etc are
+filtered anyway), there is no \"laxmatch\", and an anchored matcher
+is always a form which must do all the fontification directly.
+`limit' is a variable bound to the real limit in the context of
+the anchored matcher forms.
+
+This function does not do any hidden buffer changes, but the
+generated functions will.  (They are however used in places
+covered by the font-lock context.)"
+
+    ;; Note: Set c-font-byte-compile to nil to debug the generated
     ;; lambda more easily.
-    (byte-compile
+    (c--compile
      `(lambda (limit)
         (let ( ;; The font-lock package in Emacs is known to clobber
               ;; `parse-sexp-lookup-properties' (when it exists).
@@ -402,44 +414,44 @@
         nil)))
 
   (defun c-make-font-lock-BO-decl-search-function (regexp &rest highlights)
-    ;; This function makes a byte compiled function that first moves back
-    ;; to the beginning of the current declaration (if any), then searches
-    ;; forward for matcher elements (as in `font-lock-keywords') and
-    ;; fontifies them.
-    ;;
-    ;; The motivation for moving back to the declaration start is to
-    ;; establish a context for the current text when, e.g., a character
-    ;; is typed on a C++ inheritance continuation line, or a jit-lock
-    ;; chunk starts there.
-    ;;
-    ;; The new function works much like a matcher element in
-    ;; `font-lock-keywords'.  It cuts out a little bit of the overhead
-    ;; compared to a real matcher.  The main reason is however to pass the
-    ;; real search limit to the anchored matcher(s), since most (if not
-    ;; all) font-lock implementations arbitrarily limit anchored matchers
-    ;; to the same line, and also to insulate against various other
-    ;; irritating differences between the different (X)Emacs font-lock
-    ;; packages.
-    ;;
-    ;; REGEXP is the matcher, which must be a regexp.  Only matches
-    ;; where the beginning is outside any comment or string literal are
-    ;; significant.
-    ;;
-    ;; HIGHLIGHTS is a list of highlight specs, just like in
-    ;; `font-lock-keywords', with these limitations: The face is always
-    ;; overridden (no big disadvantage, since hits in comments etc are
-    ;; filtered anyway), there is no "laxmatch", and an anchored matcher
-    ;; is always a form which must do all the fontification directly.
-    ;; `limit' is a variable bound to the real limit in the context of
-    ;; the anchored matcher forms.
-    ;;
-    ;; This function does not do any hidden buffer changes, but the
-    ;; generated functions will.  (They are however used in places
-    ;; covered by the font-lock context.)
-
-    ;; Note: Replace `byte-compile' with `eval' to debug the generated
+    "This function makes a byte compiled function that first moves back
+to the beginning of the current declaration (if any), then searches
+forward for matcher elements (as in `font-lock-keywords') and
+fontifies them.
+
+The motivation for moving back to the declaration start is to
+establish a context for the current text when, e.g., a character
+is typed on a C++ inheritance continuation line, or a jit-lock
+chunk starts there.
+
+The new function works much like a matcher element in
+`font-lock-keywords'.  It cuts out a little bit of the overhead
+compared to a real matcher.  The main reason is however to pass the
+real search limit to the anchored matcher(s), since most (if not
+all) font-lock implementations arbitrarily limit anchored matchers
+to the same line, and also to insulate against various other
+irritating differences between the different (X)Emacs font-lock
+packages.
+
+REGEXP is the matcher, which must be a regexp.  Only matches
+where the beginning is outside any comment or string literal are
+significant.
+
+HIGHLIGHTS is a list of highlight specs, just like in
+`font-lock-keywords', with these limitations: The face is always
+overridden (no big disadvantage, since hits in comments etc are
+filtered anyway), there is no \"laxmatch\", and an anchored matcher
+is always a form which must do all the fontification directly.
+`limit' is a variable bound to the real limit in the context of
+the anchored matcher forms.
+
+This function does not do any hidden buffer changes, but the
+generated functions will.  (They are however used in places
+covered by the font-lock context.)"
+
+    ;; Note: Set c-font-byte-compile to nil to debug the generated
     ;; lambda more easily.
-    (byte-compile
+    (c--compile
      `(lambda (limit)
         (let ( ;; The font-lock package in Emacs is known to clobber
               ;; `parse-sexp-lookup-properties' (when it exists).
@@ -457,40 +469,40 @@
         nil)))
 
   (defun c-make-font-lock-context-search-function (normal &rest state-stanzas)
-    ;; This function makes a byte compiled function that works much like
-    ;; a matcher element in `font-lock-keywords', with the following
-    ;; enhancement: the generated function will test for particular "font
-    ;; lock contexts" at the start of the region, i.e. is this point in
-    ;; the middle of some particular construct?  if so the generated
-    ;; function will first fontify the tail of the construct, before
-    ;; going into the main loop and fontify full constructs up to limit.
-    ;;
-    ;; The generated function takes one parameter called `limit', and
-    ;; will fontify the region between POINT and LIMIT.
-    ;;
-    ;; NORMAL is a list of the form (REGEXP HIGHLIGHTS .....), and is
-    ;; used to fontify the "regular" bit of the region.
-    ;; STATE-STANZAS is list of elements of the form (STATE LIM REGEXP
-    ;; HIGHLIGHTS), each element coding one possible font lock context.
-
-    ;; o - REGEXP is a font-lock regular expression (NOT a function),
-    ;; o - HIGHLIGHTS is a list of zero or more highlighters as defined
-    ;;   on page "Search-based Fontification" in the elisp manual.  As
-    ;;   yet (2009-06), they must have OVERRIDE set, and may not have
-    ;;   LAXMATCH set.
-    ;;
-    ;; o - STATE is the "font lock context" (e.g. in-cpp-expr) and is
-    ;;   not quoted.
-    ;; o - LIM is a lisp form whose evaluation will yield the limit
-    ;;   position in the buffer for fontification by this stanza.
-    ;;
-    ;; This function does not do any hidden buffer changes, but the
-    ;; generated functions will.  (They are however used in places
-    ;; covered by the font-lock context.)
-    ;;
-    ;; Note: Replace `byte-compile' with `eval' to debug the generated
+    "This function makes a byte compiled function that works much like
+a matcher element in `font-lock-keywords', with the following
+enhancement: the generated function will test for particular \"font
+lock contexts\" at the start of the region, i.e. is this point in
+the middle of some particular construct?  if so the generated
+function will first fontify the tail of the construct, before
+going into the main loop and fontify full constructs up to limit.
+
+The generated function takes one parameter called `limit', and
+will fontify the region between POINT and LIMIT.
+
+NORMAL is a list of the form (REGEXP HIGHLIGHTS .....), and is
+used to fontify the \"regular\" bit of the region.
+STATE-STANZAS is list of elements of the form (STATE LIM REGEXP
+HIGHLIGHTS), each element coding one possible font lock context.
+
+o - REGEXP is a font-lock regular expression (NOT a function),
+o - HIGHLIGHTS is a list of zero or more highlighters as defined
+  on page \"Search-based Fontification\" in the elisp manual.  As
+  yet (2009-06), they must have OVERRIDE set, and may not have
+  LAXMATCH set.
+
+o - STATE is the \"font lock context\" (e.g. in-cpp-expr) and is
+  not quoted.
+o - LIM is a lisp form whose evaluation will yield the limit
+  position in the buffer for fontification by this stanza.
+
+This function does not do any hidden buffer changes, but the
+generated functions will.  (They are however used in places
+covered by the font-lock context.)"
+
+    ;; Note: Set c-font-byte-compile to nil to debug the generated
     ;; lambda more easily.
-    (byte-compile
+    (c--compile
      `(lambda (limit)
         (let ( ;; The font-lock package in Emacs is known to clobber
               ;; `parse-sexp-lookup-properties' (when it exists).
@@ -522,10 +534,10 @@
     (form &rest &or ("quote" (&rest form)) ("`" (&rest form)) form)));))
 
 (defun c-fontify-recorded-types-and-refs ()
-  ;; Convert the ranges recorded on `c-record-type-identifiers' and
-  ;; `c-record-ref-identifiers' to fontification.
-  ;;
-  ;; This function does hidden buffer changes.
+  "Convert the ranges recorded on `c-record-type-identifiers' and
+`c-record-ref-identifiers' to fontification.
+  
+This function does hidden buffer changes."
   (let (elem)
     (while (consp c-record-type-identifiers)
       (setq elem (car c-record-type-identifiers)
@@ -581,7 +593,7 @@ stuff.  Used on level 1 and higher."
 
                        ;; Use an anchored matcher to put paren syntax
                        ;; on the brackets.
-                       (,(byte-compile
+                       (,(c--compile
                           `(lambda (limit)
                              (let ((beg (match-beginning
                                          ,(+ ncle-depth re-depth sws-depth 1)))
@@ -683,10 +695,10 @@ stuff.  Used on level 1 and higher."
                          "\\)")
                  `(,(1+ ncle-depth) c-preprocessor-face-name t)))
 
-              (eval . (list ,(c-make-syntactic-matcher
-                              (concat noncontinued-line-end
-                                      (c-lang-const c-opt-cpp-prefix)
-                                      "if\\(n\\)def\\>"))
+              (eval . (list ',(c-make-syntactic-matcher
+                               (concat noncontinued-line-end
+                                       (c-lang-const c-opt-cpp-prefix)
+                                       "if\\(n\\)def\\>"))
                             ,(+ ncle-depth 1)
                             c-negation-char-face-name
                             'append))
@@ -745,11 +757,11 @@ casts and declarations are fontified.  Used on level 2 and higher."
       ;; this, but it doesn't give the control we want since any
       ;; fontification done inside the function will be
       ;; unconditionally overridden.
-      ,(c-make-font-lock-search-function
-        ;; Match a char before the string starter to make
-        ;; `c-skip-comments-and-strings' work correctly.
-        (concat ".\\(" c-string-limit-regexp "\\)")
-        '((c-font-lock-invalid-string)))
+      (,(c-make-font-lock-search-function
+         ;; Match a char before the string starter to make
+         ;; `c-skip-comments-and-strings' work correctly.
+         (concat ".\\(" c-string-limit-regexp "\\)")
+         '((c-font-lock-invalid-string))))
 
       ;; Fontify keyword constants.
       ,@(when (c-lang-const c-constant-kwds)
@@ -801,7 +813,8 @@ casts and declarations are fontified.  Used on level 2 and higher."
                                     (c-backward-syntactic-ws)
                                     (setq id-end (point))
                                     (< (skip-chars-backward
-                                        ,(c-lang-const c-symbol-chars)) 0))
+                                        ,(c-lang-const c-symbol-chars))
+                                       0))
                                   (not (get-text-property (point) 'face)))
                         (c-put-font-lock-face (point) id-end
                                               c-reference-face-name)
@@ -809,7 +822,7 @@ casts and declarations are fontified.  Used on level 2 and higher."
                     nil
                     (goto-char (match-end 0)))))
 
-            `((,(byte-compile
+            `((,(c--compile
                  ;; Must use a function here since we match longer than
                  ;; we want to move before doing a new search.  This is
                  ;; not necessary for XEmacs since it restarts the
@@ -1564,9 +1577,7 @@ casts and declarations are fontified.  Used on level 2 and higher."
   ;; Note that this function won't attempt to fontify beyond the end of the
   ;; current enum block, if any.
   (let* ((paren-state (c-parse-state))
-         (encl-pos (c-most-enclosing-brace paren-state))
-         (start (point))
-        )
+         (encl-pos (c-most-enclosing-brace paren-state)))
     (when (and
            encl-pos
            (eq (char-after encl-pos) ?\{)
@@ -1617,17 +1628,16 @@ on level 2 only and so aren't combined with `c-complex-decl-matchers'."
   t `(;; Objective-C methods.
       ,@(when (c-major-mode-is 'objc-mode)
           `((,(c-lang-const c-opt-method-key)
-             (,(byte-compile
-                (lambda (limit)
-                  (let (;; The font-lock package in Emacs is known to clobber
-                        ;; `parse-sexp-lookup-properties' (when it exists).
-                        (parse-sexp-lookup-properties
-                         (cc-eval-when-compile
-                           (boundp 'parse-sexp-lookup-properties))))
-                    (save-restriction
-                      (narrow-to-region (point-min) limit)
-                      (c-font-lock-objc-method)))
-                  nil))
+             (,(lambda (limit)
+                 (let (;; The font-lock package in Emacs is known to clobber
+                       ;; `parse-sexp-lookup-properties' (when it exists).
+                       (parse-sexp-lookup-properties
+                        (cc-eval-when-compile
+                          (boundp 'parse-sexp-lookup-properties))))
+                   (save-restriction
+                     (narrow-to-region (point-min) limit)
+                     (c-font-lock-objc-method)))
+                 nil)
               (goto-char (match-end 1))))))
 
       ;; Fontify all type names and the identifiers in the
@@ -1742,7 +1752,7 @@ on level 2 only and so aren't combined with `c-complex-decl-matchers'."
 
       ;; Fontify types preceded by `c-type-prefix-kwds' (e.g. "struct").
       ,@(when (c-lang-const c-type-prefix-kwds)
-          `((,(byte-compile
+          `((,(c--compile
                `(lambda (limit)
                   (c-fontify-types-and-refs
                       ((c-promote-possible-types t)
@@ -2295,7 +2305,7 @@ need for `c++-font-lock-extra-types'.")
      limit
      "[-+]"
      nil
-     (lambda (match-pos inside-macro)
+     (lambda (_match-pos _inside-macro)
        (forward-char)
        (c-font-lock-objc-method))))
   nil)
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index 73b75dc671a..daecc45c008 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -153,8 +153,8 @@
         c-emacs-variable-inits-tail c-emacs-variable-inits))
 
 (defmacro c-lang-defvar (var val &optional doc)
-  "Declares the buffer local variable VAR to get the value VAL.  VAL is
-evaluated and assigned at mode initialization.  More precisely, VAL is
+  "Declare the buffer local variable VAR to get the value VAL.
+VAL is evaluated and assigned at mode initialization.  More precisely, VAL is
 evaluated and bound to VAR when the result from the macro
 `c-init-language-vars' is evaluated.
 
@@ -218,55 +218,54 @@ the evaluated constant value at compile time."
   ;; Some helper functions used when building the language constants.
 
   (defun c-filter-ops (ops opgroup-filter op-filter &optional xlate)
-    ;; Extract a subset of the operators in the list OPS in a DWIM:ey
-    ;; way.  The return value is a plain list of operators:
-    ;;
-    ;; OPS either has the structure of `c-operators', is a single
-    ;; group in `c-operators', or is a plain list of operators.
-    ;;
-    ;; OPGROUP-FILTER specifies how to select the operator groups.  It
-    ;; can be t to choose all groups, a list of group type symbols
-    ;; (such as 'prefix) to accept, or a function which will be called
-    ;; with the group symbol for each group and should return non-nil
-    ;; if that group is to be included.
-    ;;
-    ;; If XLATE is given, it's a function which is called for each
-    ;; matching operator and its return value is collected instead.
-    ;; If it returns a list, the elements are spliced directly into
-    ;; the final result, which is returned as a list with duplicates
-    ;; removed using `equal'.
-    ;;
-    ;; `c-mode-syntax-table' for the current mode is in effect during
-    ;; the whole procedure.
+    "Extract a subset of the operators in the list OPS in a DWIM:ey way.
+The return value is a plain list of operators:
+
+OPS either has the structure of `c-operators', is a single
+group in `c-operators', or is a plain list of operators.
+
+OPGROUP-FILTER specifies how to select the operator groups.  It
+can be t to choose all groups, a list of group type symbols
+\(such as 'prefix) to accept, or a function which will be called
+with the group symbol for each group and should return non-nil
+if that group is to be included.
+
+If XLATE is given, it's a function which is called for each
+matching operator and its return value is collected instead.
+If it returns a list, the elements are spliced directly into
+the final result, which is returned as a list with duplicates
+removed using `equal'.
+
+`c-mode-syntax-table' for the current mode is in effect during
+the whole procedure."
     (unless (listp (car-safe ops))
       (setq ops (list ops)))
-    (cond ((eq opgroup-filter t)
-           (setq opgroup-filter (lambda (opgroup) t)))
-          ((not (functionp opgroup-filter))
-           (setq opgroup-filter `(lambda (opgroup)
-                                   (memq opgroup ',opgroup-filter)))))
-    (cond ((eq op-filter t)
-           (setq op-filter (lambda (op) t)))
-          ((stringp op-filter)
-           (setq op-filter `(lambda (op)
-                              (string-match ,op-filter op)))))
-    (unless xlate
-      (setq xlate 'identity))
-    (c-with-syntax-table (c-lang-const c-mode-syntax-table)
-      (cl-delete-duplicates
-       (cl-mapcan (lambda (opgroup)
-                 (when (if (symbolp (car opgroup))
-                           (when (funcall opgroup-filter (car opgroup))
-                             (setq opgroup (cdr opgroup))
-                             t)
-                         t)
-                   (cl-mapcan (lambda (op)
-                             (when (funcall op-filter op)
-                               (let ((res (funcall xlate op)))
-                                 (if (listp res) res (list res)))))
-                           opgroup)))
-               ops)
-       :test 'equal))))
+    (let ((opgroup-filter
+           (cond ((eq opgroup-filter t) (lambda (opgroup) t))
+                 ((not (functionp opgroup-filter))
+                  `(lambda (opgroup) (memq opgroup ',opgroup-filter)))
+                 (t opgroup-filter)))
+          (op-filter
+           (cond ((eq op-filter t) (lambda (op) t))
+                 ((stringp op-filter) `(lambda (op) (string-match ,op-filter op)))
+                 (t op-filter))))
+      (unless xlate
+        (setq xlate #'identity))
+      (c-with-syntax-table (c-lang-const c-mode-syntax-table)
+        (cl-delete-duplicates
+         (cl-mapcan (lambda (opgroup)
+                      (when (if (symbolp (car opgroup))
+                                (when (funcall opgroup-filter (car opgroup))
+                                  (setq opgroup (cdr opgroup))
+                                  t)
+                              t)
+                        (cl-mapcan (lambda (op)
+                                     (when (funcall op-filter op)
+                                       (let ((res (funcall xlate op)))
+                                         (if (listp res) res (list res)))))
+                                   opgroup)))
+                    ops)
+         :test #'equal)))))
 
 
 ;;; Various mode specific values that aren't language related.
@@ -350,16 +349,12 @@ the comment syntax to handle both line style \"//\" and block style
   ;; all languages now require dual comments, we make this the
   ;; default.
   (cond
-   ;; XEmacs
-   ((memq '8-bit c-emacs-features)
+   ((featurep 'xemacs)
     (modify-syntax-entry ?/  ". 1456" table)
     (modify-syntax-entry ?*  ". 23"   table))
-   ;; Emacs
-   ((memq '1-bit c-emacs-features)
+   (t
     (modify-syntax-entry ?/  ". 124b" table)
-    (modify-syntax-entry ?*  ". 23"   table))
-   ;; incompatible
-   (t (error "CC Mode is incompatible with this version of Emacs")))
+    (modify-syntax-entry ?*  ". 23"   table)))
 
   (modify-syntax-entry ?\n "> b"  table)
   ;; Give CR the same syntax as newline, for selective-display
@@ -368,19 +363,19 @@ the comment syntax to handle both line style \"//\" and block style
 (c-lang-defconst c-make-mode-syntax-table
   "Functions that generates the mode specific syntax tables.
 The syntax tables aren't stored directly since they're quite large."
-  t `(lambda ()
-       (let ((table (make-syntax-table)))
-         (c-populate-syntax-table table)
-         ;; Mode specific syntaxes.
-         ,(cond ((or (c-major-mode-is 'objc-mode) (c-major-mode-is 'java-mode))
-                 ;; Let '@' be part of symbols in ObjC to cope with
-                 ;; its compiler directives as single keyword tokens.
-                 ;; This is then necessary since it's assumed that
-                 ;; every keyword is a single symbol.
-                 `(modify-syntax-entry ?@ "_" table))
-                ((c-major-mode-is 'pike-mode)
-                 `(modify-syntax-entry ?@ "." table)))
-         table)))
+  t (lambda ()
+      (let ((table (make-syntax-table)))
+        (c-populate-syntax-table table)
+        ;; Mode specific syntaxes.
+        (cond ((or (c-major-mode-is 'objc-mode) (c-major-mode-is 'java-mode))
+               ;; Let '@' be part of symbols in ObjC to cope with
+               ;; its compiler directives as single keyword tokens.
+               ;; This is then necessary since it's assumed that
+               ;; every keyword is a single symbol.
+               (modify-syntax-entry ?@ "_" table))
+              ((c-major-mode-is 'pike-mode)
+               (modify-syntax-entry ?@ "." table)))
+        table)))
 
 (c-lang-defconst c-mode-syntax-table
   ;; The syntax tables in evaluated form.  Only used temporarily when
@@ -398,8 +393,8 @@ The syntax tables aren't stored directly since they're quite large."
   ;; CALLED!!!
   t   nil
   (java c++) `(lambda ()
-         (let ((table (funcall ,(c-lang-const c-make-mode-syntax-table))))
-           (modify-syntax-entry ?< "(>" table)
+                (let ((table (funcall ,(c-lang-const c-make-mode-syntax-table))))
+                  (modify-syntax-entry ?< "(>" table)
            (modify-syntax-entry ?> ")<" table)
            table)))
 (c-lang-defvar c++-template-syntax-table
@@ -419,9 +414,9 @@ The syntax tables aren't stored directly since they're quite large."
             (let ((table (funcall ,(c-lang-const c-make-mode-syntax-table))))
               (modify-syntax-entry ?\( "." table)
               (modify-syntax-entry ?\) "." table)
-              (modify-syntax-entry ?\[ "." table)
-              (modify-syntax-entry ?\] "." table)
-              (modify-syntax-entry ?\{ "." table)
+              (modify-syntax-entry ?\[ "." table)
+              (modify-syntax-entry ?\] "." table)
+              (modify-syntax-entry ?\{ "." table)
               (modify-syntax-entry ?\} "." table)
               table))))
 (c-lang-defvar c-no-parens-syntax-table
@@ -1142,7 +1137,8 @@ operators."
   c++  (append '("&" "<%" "%>" "<:" ":>" "%:" "%:%:")
                (c-lang-const c-other-op-syntax-tokens))
   objc (append '("#" "##"               ; Used by cpp.
-                 "+" "-") (c-lang-const c-other-op-syntax-tokens))
+                 "+" "-")
+               (c-lang-const c-other-op-syntax-tokens))
   idl  (append '("#" "##")              ; Used by cpp.
                (c-lang-const c-other-op-syntax-tokens))
   pike (append '("..")
@@ -2469,27 +2465,24 @@ Note that Java specific rules are currently applied to tell this from
 
 ;; Note: No `*-kwds' language constants may be defined below this point.
 
-(eval-and-compile
-  (defconst c-kwds-lang-consts
-    ;; List of all the language constants that contain keyword lists.
-    (let (list)
-      (mapatoms (lambda (sym)
-                  (when (and (boundp sym)
-                             (string-match "-kwds\\'" (symbol-name sym)))
-                    ;; Make the list of globally interned symbols
-                    ;; instead of ones interned in `c-lang-constants'.
-                    (setq list (cons (intern (symbol-name sym)) list))))
-                c-lang-constants)
-      list)))
+(defconst c-kwds-lang-consts
+  ;; List of all the language constants that contain keyword lists.
+  (let (list)
+    (mapatoms (lambda (sym)
+                (when (and ;; (boundp sym)
+                       (string-match "-kwds\\'" (symbol-name sym)))
+                  ;; Make the list of globally interned symbols
+                  ;; instead of ones interned in `c-lang-constants'.
+                  (setq list (cons (intern (symbol-name sym)) list))))
+              c-lang-constants)
+    list))
 
 (c-lang-defconst c-keywords
   ;; All keywords as a list.
   t (cl-delete-duplicates
-     (c-lang-defconst-eval-immediately
-      `(append ,@(mapcar (lambda (kwds-lang-const)
-                           `(c-lang-const ,kwds-lang-const))
-                         c-kwds-lang-consts)
-               nil))
+     (apply #'append (mapcar (lambda (kwds-lang-const)
+                              (c-get-lang-constant kwds-lang-const))
+                            c-kwds-lang-consts))
      :test 'string-equal))
 
 (c-lang-defconst c-keywords-regexp
@@ -2501,18 +2494,10 @@ Note that Java specific rules are currently applied to tell this from
   ;; An alist with all the keywords in the cars.  The cdr for each
   ;; keyword is a list of the symbols for the `*-kwds' lists that
   ;; contains it.
-  t (let ((kwd-list-alist
-           (c-lang-defconst-eval-immediately
-            `(list ,@(mapcar (lambda (kwds-lang-const)
-                               `(cons ',kwds-lang-const
-                                      (c-lang-const ,kwds-lang-const)))
-                             c-kwds-lang-consts))))
-          lang-const kwd-list kwd
+  t (let (kwd-list kwd
           result-alist elem)
-      (while kwd-list-alist
-        (setq lang-const (caar kwd-list-alist)
-              kwd-list (cdar kwd-list-alist)
-              kwd-list-alist (cdr kwd-list-alist))
+      (dolist (lang-const c-kwds-lang-consts)
+        (setq kwd-list (c-get-lang-constant lang-const))
         (while kwd-list
           (setq kwd (car kwd-list)
                 kwd-list (cdr kwd-list))
@@ -2598,12 +2583,13 @@ Note that Java specific rules are currently applied to tell this from
                             right-assoc-sequence)
                           t))
 
-           (unambiguous-prefix-ops (set-difference nonkeyword-prefix-ops
-                                                   in-or-postfix-ops
-                                                   :test 'string-equal))
-           (ambiguous-prefix-ops (intersection nonkeyword-prefix-ops
-                                               in-or-postfix-ops
-                                               :test 'string-equal)))
+           ;; (unambiguous-prefix-ops (cl-set-difference nonkeyword-prefix-ops
+           ;;                                      in-or-postfix-ops
+           ;;                                      :test 'string-equal))
+           ;; (ambiguous-prefix-ops (cl-intersection nonkeyword-prefix-ops
+           ;;                                  in-or-postfix-ops
+           ;;                                  :test 'string-equal))
+           )
 
       (concat
        "\\("
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 1ce076734ff..7eca7e562ea 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -95,14 +95,9 @@
 (cc-require 'cc-menus)
 (cc-require 'cc-guess)
 
-;; Silence the compiler.
-(cc-bytecomp-defvar adaptive-fill-first-line-regexp) ; Emacs
-(cc-bytecomp-defun run-mode-hooks)      ; Emacs 21.1
-
 ;; We set these variables during mode init, yet we don't require
 ;; font-lock.
-(cc-bytecomp-defvar font-lock-defaults)
-(cc-bytecomp-defvar font-lock-syntactic-keywords)
+(defvar font-lock-defaults)
 
 ;; Menu support for both XEmacs and Emacs.  If you don't have easymenu
 ;; with your version of Emacs, you are incompatible!
@@ -552,11 +547,8 @@ that requires a literal mode spec at compile time."
   ;; heuristic that open parens in column 0 are defun starters.  Since
   ;; we have c-state-cache, that heuristic isn't useful and only causes
   ;; trouble, so turn it off.
-;; 2006/12/17: This facility is somewhat confused, and doesn't really seem
-;; helpful.  Comment it out for now.
-;;   (when (memq 'col-0-paren c-emacs-features)
-;;     (make-local-variable 'open-paren-in-column-0-is-defun-start)
-;;     (setq open-paren-in-column-0-is-defun-start nil))
+  (when (memq 'col-0-paren c-emacs-features)
+    (set (make-local-variable 'open-paren-in-column-0-is-defun-start) nil))
 
   (c-clear-found-types)
 
@@ -816,7 +808,7 @@ Note that the style variables are always made local to the buffer."
 (defmacro c-run-mode-hooks (&rest hooks)
   ;; Emacs 21.1 has introduced a system with delayed mode hooks that
   ;; requires the use of the new function `run-mode-hooks'.
-  (if (cc-bytecomp-fboundp 'run-mode-hooks)
+  (if (fboundp 'run-mode-hooks)
       `(run-mode-hooks ,@hooks)
     `(progn ,@(mapcar (lambda (hook) `(run-hooks ,hook)) hooks))))
 
@@ -1232,8 +1224,8 @@ This function is called from `c-common-init', once per mode initialization."
           (font-lock-mark-block-function
            . c-mark-function)))
 
-  (make-local-variable 'font-lock-fontify-region-function)
-  (setq font-lock-fontify-region-function 'c-font-lock-fontify-region)
+  (set (make-local-variable 'font-lock-fontify-region-function)
+       #'c-font-lock-fontify-region)
 
   (if (featurep 'xemacs)
       (make-local-hook 'font-lock-mode-hook))