Implement the C++11 "using" type definition.

Cease using the long obsolete c++-template-syntax-table.

* lisp/progmodes/cc-align.el (c-lineup-template-args): Cease using
c++-template-syntax-table.

* lisp/progmodes/cc-engine.el (c-beginning-of-inheritance-list)
(c-search-decl-header-end, c-beginning-of-decl-1, c-end-of-decl-1)
(c-guess-continued-construct, c-guess-basic-syntax): Cease using
c++-template-syntax-table.
(c-guess-basic-syntax): Add CASE 5D.6 to handle C++11's "using" type
definition.

* lisp/progmodes/cc-langs.el (c++-make-template-syntax-table)
(c++-template-syntax-table): Remove.
(c-equals-type-clause-kwds, c-equals-type-clause-key): New language
constants/variables.

3 files changed, 95 insertions, 101 deletions

diff --git a/lisp/progmodes/cc-align.el b/lisp/progmodes/cc-align.el
index 09887b02f3b..1b48a5a66c9 100644
--- a/lisp/progmodes/cc-align.el
+++ b/lisp/progmodes/cc-align.el
@@ -868,12 +868,11 @@ returned if there's no template argument on the first line.
 
 Works with: template-args-cont."
   (save-excursion
-    (c-with-syntax-table c++-template-syntax-table
-      (beginning-of-line)
-      (backward-up-list 1)
-      (if (and (eq (char-after) ?<)
-               (zerop (c-forward-token-2 1 nil (c-point 'eol))))
-          (vector (current-column))))))
+    (beginning-of-line)
+    (backward-up-list 1)
+    (if (and (eq (char-after) ?<)
+             (zerop (c-forward-token-2 1 nil (c-point 'eol))))
+        (vector (current-column)))))
 
 (defun c-lineup-ObjC-method-call (langelem)
   "Line up selector args as Emacs Lisp mode does with function args:
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 3d9e4fa0d35..36f5196c5e2 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -9510,11 +9510,10 @@ comment at the start of cc-engine.el for more info."
   ;; back we should search.
   ;;
   ;; This function might do hidden buffer changes.
-  (c-with-syntax-table c++-template-syntax-table
-    (c-backward-token-2 0 t lim)
-    (while (and (or (looking-at c-symbol-start)
-                    (looking-at "[<,]\\|::"))
-                (zerop (c-backward-token-2 1 t lim))))))
+  (c-backward-token-2 0 t lim)
+  (while (and (or (looking-at c-symbol-start)
+                  (looking-at "[<,]\\|::"))
+              (zerop (c-backward-token-2 1 t lim)))))
 
 (defun c-in-method-def-p ()
   ;; Return nil if we aren't in a method definition, otherwise the
@@ -9890,11 +9889,10 @@ comment at the start of cc-engine.el for more info."
                    (and (c-safe (c-backward-sexp) t)
                         (looking-at c-opt-op-identifier-prefix)))
                  (and (eq (char-before) ?<)
-                      (c-with-syntax-table c++-template-syntax-table
-                        (if (c-safe (goto-char (c-up-list-forward (point))))
-                            t
-                          (goto-char (point-max))
-                          nil)))))
+                      (if (c-safe (goto-char (c-up-list-forward (point))))
+                          t
+                        (goto-char (point-max))
+                        nil))))
           (setq base (point)))
 
       (while (and
@@ -9987,28 +9985,25 @@ comment at the start of cc-engine.el for more info."
       ;; potentially can search over a large amount of text.).  Take special
       ;; pains not to get mislead by C++'s "operator=", and the like.
       (if (and (eq move 'previous)
-               (c-with-syntax-table (if (c-major-mode-is 'c++-mode)
-                                        c++-template-syntax-table
-                                      (syntax-table))
-                 (save-excursion
-                   (and
-                    (progn
-                      (while  ; keep going back to "[;={"s until we either find
-                           ; no more, or get to one which isn't an "operator ="
-                          (and (c-syntactic-re-search-forward "[;={]" start t t t)
-                               (eq (char-before) ?=)
-                               c-overloadable-operators-regexp
-                               c-opt-op-identifier-prefix
-                               (save-excursion
-                                 (eq (c-backward-token-2) 0)
-                                 (looking-at c-overloadable-operators-regexp)
-                                 (eq (c-backward-token-2) 0)
-                                 (looking-at c-opt-op-identifier-prefix))))
-                      (eq (char-before) ?=))
-                    (c-syntactic-re-search-forward "[;{]" start t t)
-                    (eq (char-before) ?{)
-                    (c-safe (goto-char (c-up-list-forward (point))) t)
-                    (not (c-syntactic-re-search-forward ";" start t t))))))
+               (save-excursion
+                 (and
+                  (progn
+                    (while   ; keep going back to "[;={"s until we either find
+                             ; no more, or get to one which isn't an "operator ="
+                        (and (c-syntactic-re-search-forward "[;={]" start t t t)
+                             (eq (char-before) ?=)
+                             c-overloadable-operators-regexp
+                             c-opt-op-identifier-prefix
+                             (save-excursion
+                               (eq (c-backward-token-2) 0)
+                               (looking-at c-overloadable-operators-regexp)
+                               (eq (c-backward-token-2) 0)
+                               (looking-at c-opt-op-identifier-prefix))))
+                    (eq (char-before) ?=))
+                  (c-syntactic-re-search-forward "[;{]" start t t)
+                  (eq (char-before) ?{)
+                  (c-safe (goto-char (c-up-list-forward (point))) t)
+                  (not (c-syntactic-re-search-forward ";" start t t)))))
           (cons 'same nil)
         (cons move nil)))))
 
@@ -10023,10 +10018,7 @@ comment at the start of cc-engine.el for more info."
   ;; `c-end-of-macro' instead in those cases.
   ;;
   ;; This function might do hidden buffer changes.
-  (let ((start (point))
-        (decl-syntax-table (if (c-major-mode-is 'c++-mode)
-                               c++-template-syntax-table
-                             (syntax-table))))
+  (let ((start (point)))
     (catch 'return
       (c-search-decl-header-end)
 
@@ -10047,34 +10039,32 @@ comment at the start of cc-engine.el for more info."
                  (throw 'return nil)))
         (if (or (not c-opt-block-decls-with-vars-key)
                 (save-excursion
-                  (c-with-syntax-table decl-syntax-table
-                    (let ((lim (point)))
-                      (goto-char start)
-                      (not (and
-                            ;; Check for `c-opt-block-decls-with-vars-key'
-                            ;; before the first paren.
-                            (c-syntactic-re-search-forward
-                             (concat "[;=([{]\\|\\("
-                                     c-opt-block-decls-with-vars-key
-                                     "\\)")
-                             lim t t t)
-                            (match-beginning 1)
-                            (not (eq (char-before) ?_))
-                            ;; Check that the first following paren is
-                            ;; the block.
-                            (c-syntactic-re-search-forward "[;=([{]"
-                                                           lim t t t)
-                            (eq (char-before) ?{)))))))
+                  (let ((lim (point)))
+                    (goto-char start)
+                    (not (and
+                          ;; Check for `c-opt-block-decls-with-vars-key'
+                          ;; before the first paren.
+                          (c-syntactic-re-search-forward
+                           (concat "[;=\(\[{]\\|\\("
+                                   c-opt-block-decls-with-vars-key
+                                   "\\)")
+                           lim t t t)
+                          (match-beginning 1)
+                          (not (eq (char-before) ?_))
+                          ;; Check that the first following paren is
+                          ;; the block.
+                          (c-syntactic-re-search-forward "[;=\(\[{]"
+                                                         lim t t t)
+                          (eq (char-before) ?{))))))
             ;; The declaration doesn't have any of the
             ;; `c-opt-block-decls-with-vars' keywords in the
             ;; beginning, so it ends here at the end of the block.
             (throw 'return t)))
 
-      (c-with-syntax-table decl-syntax-table
-        (while (progn
-                 (if (eq (char-before) ?\;)
-                     (throw 'return t))
-                 (c-syntactic-re-search-forward ";" nil 'move t))))
+      (while (progn
+               (if (eq (char-before) ?\;)
+                   (throw 'return t))
+               (c-syntactic-re-search-forward ";" nil 'move t)))
       nil)))
 
 (defun c-looking-at-decl-block (_containing-sexp goto-start &optional limit)
@@ -11460,17 +11450,15 @@ comment at the start of cc-engine.el for more info."
      ((and (c-major-mode-is 'c++-mode)
            (save-excursion
              (goto-char indent-point)
-             (c-with-syntax-table c++-template-syntax-table
-               (setq placeholder (c-up-list-backward)))
+             (setq placeholder (c-up-list-backward))
              (and placeholder
                   (eq (char-after placeholder) ?<)
                   (/= (char-before placeholder) ?<)
                   (progn
                     (goto-char (1+ placeholder))
                     (not (looking-at c-<-op-cont-regexp))))))
-      (c-with-syntax-table c++-template-syntax-table
-        (goto-char placeholder)
-        (c-beginning-of-statement-1 containing-sexp t))
+      (goto-char placeholder)
+      (c-beginning-of-statement-1 containing-sexp t)
       (if (save-excursion
             (c-backward-syntactic-ws containing-sexp)
             (eq (char-before) ?<))
@@ -12130,21 +12118,38 @@ comment at the start of cc-engine.el for more info."
               ;; NB: No c-after-special-operator-id stuff in this
               ;; clause - we assume only C++ needs it.
               (c-syntactic-skip-backward "^;,=" lim t))
+            (setq placeholder (point))
             (memq (char-before) '(?, ?= ?<)))
           (cond
 
+           ;; CASE 5D.6: Something like C++11's "using foo = <type-exp>"
+           ((save-excursion
+              (and (eq (char-before placeholder) ?=)
+                   (goto-char placeholder)
+                   (eq (c-backward-token-2 1 nil lim) 0)
+                   (eq (point) (1- placeholder))
+                   (eq (c-beginning-of-statement-1 lim) 'same)
+                   (looking-at c-equals-type-clause-key)
+                   (let ((preserve-point (point)))
+                     (when
+                         (and
+                          (eq (c-forward-token-2 1 nil nil) 0)
+                          (c-on-identifier))
+                       (setq placeholder preserve-point)))))
+            (c-add-syntax
+             'statement-cont placeholder)
+                   )
+
            ;; CASE 5D.3: perhaps a template list continuation?
            ((and (c-major-mode-is 'c++-mode)
                  (save-excursion
                    (save-restriction
-                     (c-with-syntax-table c++-template-syntax-table
-                       (goto-char indent-point)
-                       (setq placeholder (c-up-list-backward))
-                       (and placeholder
-                            (eq (char-after placeholder) ?<))))))
-            (c-with-syntax-table c++-template-syntax-table
-              (goto-char placeholder)
-              (c-beginning-of-statement-1 lim t))
+                     (goto-char indent-point)
+                     (setq placeholder (c-up-list-backward))
+                     (and placeholder
+                          (eq (char-after placeholder) ?<)))))
+            (goto-char placeholder)
+            (c-beginning-of-statement-1 lim t)
             (if (save-excursion
                   (c-backward-syntactic-ws lim)
                   (eq (char-before) ?<))
@@ -12168,8 +12173,7 @@ comment at the start of cc-engine.el for more info."
                    (and (looking-at c-class-key)
                         (zerop (c-forward-token-2 2 nil indent-point))
                         (if (eq (char-after) ?<)
-                            (c-with-syntax-table c++-template-syntax-table
-                              (zerop (c-forward-token-2 1 t indent-point)))
+                            (zerop (c-forward-token-2 1 t indent-point))
                           t)
                         (eq (char-after) ?:))))
             (goto-char placeholder)
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index 53cb7f7f725..1b44c75fe6c 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -392,27 +392,6 @@ The syntax tables aren't stored directly since they're quite large."
   ;; the constants in this file are evaluated.
   t (funcall (c-lang-const c-make-mode-syntax-table)))
 
-(c-lang-defconst c++-make-template-syntax-table
-  ;; A variant of `c++-mode-syntax-table' that defines `<' and `>' as
-  ;; parenthesis characters.  Used temporarily when template argument
-  ;; lists are parsed.  Note that this encourages incorrect parsing of
-  ;; templates since they might contain normal operators that uses the
-  ;; '<' and '>' characters.  Therefore this syntax table might go
-  ;; away when CC Mode handles templates correctly everywhere.  WHILE
-  ;; THIS SYNTAX TABLE IS CURRENT, `c-parse-state' MUST _NOT_ BE
-  ;; CALLED!!!
-  t   nil
-  (java c++) `(lambda ()
-         (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
-  (and (c-lang-const c++-make-template-syntax-table)
-       ;; The next eval remove a superfluous ' from '(lambda.  This
-       ;; gets rid of compilation warnings.
-       (funcall (eval (c-lang-const c++-make-template-syntax-table)))))
-
 (c-lang-defconst c-make-no-parens-syntax-table
   ;; A variant of the standard syntax table which is used to find matching
   ;; "<"s and ">"s which have been marked as parens using syntax table
@@ -2210,6 +2189,18 @@ will be handled."
   pike (append (c-lang-const c-class-decl-kwds)
                '("constant")))
 
+(c-lang-defconst c-equals-type-clause-kwds
+  "Keywords which are followed by an identifier then an \"=\"
+  sign, which declares the identifier to be a type."
+  t nil
+  c++ '("using"))
+
+(c-lang-defconst c-equals-type-clause-key
+  ;; A regular expression which matches any member of
+  ;; `c-equals-type-clause-kwds'.
+  t (c-make-keywords-re t (c-lang-const c-equals-type-clause-kwds)))
+(c-lang-defvar c-equals-type-clause-key (c-lang-const c-equals-type-clause-key))
+
 (c-lang-defconst c-modifier-kwds
   "Keywords that can prefix normal declarations of identifiers
 \(and typically act as flags).  Things like argument declarations