Comment change.

author: Richard M. Stallman 2001-11-29 00:49:32 +0000
committer: Richard M. Stallman 2001-11-29 00:49:32 +0000
commit: bf5367b9c5c6bece7e66812fb53192cb376837cb (patch)
tree: 5ef611bec316796d6c28b48a282e30008276c303
parent: ea8c55c919321f786865890f5bee6f0cad9f815a (diff)
download: emacs-bf5367b9c5c6bece7e66812fb53192cb376837cb.tar.gz
emacs-bf5367b9c5c6bece7e66812fb53192cb376837cb.zip
2 files changed, 105 insertions, 105 deletions
diff --git a/lisp/obsolete/c-mode.el b/lisp/obsolete/c-mode.el
index ae17183a2c2..7224f251ecf 100644
--- a/lisp/obsolete/c-mode.el
+++ b/lisp/obsolete/c-mode.el
@@ -244,59 +244,59 @@ regardless of where in the line point is when the TAB command is used."
    ;; Example of generic expression for finding prototypes, structs, unions, enums.
    ;; Uncomment if you want to find these too.  It will be a bit slower gathering
    ;; the indexes.
-                                ;    ("Prototypes"
+;;;    ("Prototypes"
-                                ;     (,
+;;;     (,
-                                ;      (concat
+;;;      (concat
-                                ;       "^"                               ; beginning of line is required
+;;;       "^"                             ; beginning of line is required
-                                ;       "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
+;;;       "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
-                                ;       "\\([a-zA-Z0-9_:]+[ \t]+\\)?"     ; type specs; there can be no
+;;;       "\\([a-zA-Z0-9_:]+[ \t]+\\)?"   ; type specs; there can be no
-                                ;       "\\([a-zA-Z0-9_:]+[ \t]+\\)?"     ; more than 3 tokens, right?
+;;;       "\\([a-zA-Z0-9_:]+[ \t]+\\)?"   ; more than 3 tokens, right?
-                                ;       "\\("                             ; last type spec including */&
+;;;       "\\("                           ; last type spec including */&
-                                ;       "[a-zA-Z0-9_:]+"
+;;;       "[a-zA-Z0-9_:]+"
-                                ;       "\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)"        ; either pointer/ref sign or whitespace
+;;;       "\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)"      ; either pointer/ref sign or whitespace
-                                ;       "\\)?"                            ; if there is a last type spec
+;;;       "\\)?"                                  ; if there is a last type spec
-                                ;       "\\("                         ; name; take that into the imenu entry
+;;;       "\\("                       ; name; take that into the imenu entry
-                                ;       "[a-zA-Z0-9_:~]+"                     ; member function, ctor or dtor...
+;;;       "[a-zA-Z0-9_:~]+"                   ; member function, ctor or dtor...
-                                ;                                       ; (may not contain * because then
+;;;                                     ; (may not contain * because then
-                                ;                                       ; "a::operator char*" would become "char*"!)
+;;;                                     ; "a::operator char*" would become "char*"!)
-                                ;       "\\|"
+;;;       "\\|"
-                                ;       "\\([a-zA-Z0-9_:~]*::\\)?operator"
+;;;       "\\([a-zA-Z0-9_:~]*::\\)?operator"
-                                ;       "[^a-zA-Z1-9_][^(]*"          ; ...or operator
+;;;       "[^a-zA-Z1-9_][^(]*"        ; ...or operator
-                                ;       " \\)"
+;;;       " \\)"
-                                ;       "[ \t]*([^)]*)[ \t\n]*;"        ; require ';' after
+;;;       "[ \t]*([^)]*)[ \t\n]*;"      ; require ';' after
-                                ;                                       ; the (...) Can't
+;;;                                     ; the (...) Can't
-                                ;                                       ; catch cases with () inside the parentheses
+;;;                                     ; catch cases with () inside the parentheses
-                                ;                                       ; surrounding the parameters
+;;;                                     ; surrounding the parameters
-                                ;                                       ; (like "int foo(int a=bar());"
+;;;                                     ; (like "int foo(int a=bar());"
-                                ;       )) 6)
+;;;       )) 6)
-                                ;    ("Struct"
+;;;    ("Struct"
-                                ;     (, (concat
+;;;     (, (concat
-                                ;        "^"                            ; beginning of line is required
+;;;      "^"                            ; beginning of line is required
-                                ;        "\\(static[ \t]+\\)?"          ; there may be static or const.
+;;;      "\\(static[ \t]+\\)?"          ; there may be static or const.
-                                ;        "\\(const[ \t]+\\)?"
+;;;      "\\(const[ \t]+\\)?"
-                                ;        "struct[ \t]+"
+;;;      "struct[ \t]+"
-                                ;        "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
+;;;      "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
-                                ;        "[ \t]*[{]"
+;;;      "[ \t]*[{]"
-                                ;        )) 3)
+;;;      )) 3)
-                                ;    ("Enum"
+;;;    ("Enum"
-                                ;     (, (concat
+;;;     (, (concat
-                                ;        "^"                            ; beginning of line is required
+;;;      "^"                            ; beginning of line is required
-                                ;        "\\(static[ \t]+\\)?"          ; there may be static or const.
+;;;      "\\(static[ \t]+\\)?"          ; there may be static or const.
-                                ;        "\\(const[ \t]+\\)?"
+;;;      "\\(const[ \t]+\\)?"
-                                ;        "enum[ \t]+"
+;;;      "enum[ \t]+"
-                                ;        "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
+;;;      "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
-                                ;        "[ \t]*[{]"
+;;;      "[ \t]*[{]"
-                                ;        )) 3)
+;;;      )) 3)
-                                ;    ("Union"
+;;;    ("Union"
-                                ;     (, (concat
+;;;     (, (concat
-                                ;        "^"                            ; beginning of line is required
+;;;      "^"                            ; beginning of line is required
-                                ;        "\\(static[ \t]+\\)?"          ; there may be static or const.
+;;;      "\\(static[ \t]+\\)?"          ; there may be static or const.
-                                ;        "\\(const[ \t]+\\)?"
+;;;      "\\(const[ \t]+\\)?"
-                                ;        "union[ \t]+"
+;;;      "union[ \t]+"
-                                ;        "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
+;;;      "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
-                                ;        "[ \t]*[{]"
+;;;      "[ \t]*[{]"
-                                ;        )) 3)
+;;;      )) 3)
    )
  "Imenu generic expression for C mode.  See `imenu-generic-expression'.")
diff --git a/lisp/obsolete/cplus-md.el b/lisp/obsolete/cplus-md.el
index 7b7e3c4d26b..5eb219da6b4 100644
--- a/lisp/obsolete/cplus-md.el
+++ b/lisp/obsolete/cplus-md.el
@@ -211,59 +211,59 @@ list.  Nil indicates to just after the paren."
    ;; Example of generic expression for finding prototypes, structs, unions, enums.
    ;; Uncomment if you want to find these too.  It will be a bit slower gathering
    ;; the indexes.
-                                ;    ("Prototypes"
+;;;    ("Prototypes"
-                                ;     (,
+;;;     (,
-                                ;      (concat
+;;;      (concat
-                                ;       "^"                               ; beginning of line is required
+;;;       "^"                             ; beginning of line is required
-                                ;       "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
+;;;       "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
-                                ;       "\\([a-zA-Z0-9_:]+[ \t]+\\)?"     ; type specs; there can be no
+;;;       "\\([a-zA-Z0-9_:]+[ \t]+\\)?"   ; type specs; there can be no
-                                ;       "\\([a-zA-Z0-9_:]+[ \t]+\\)?"     ; more than 3 tokens, right?
+;;;       "\\([a-zA-Z0-9_:]+[ \t]+\\)?"   ; more than 3 tokens, right?
-                                ;       "\\("                             ; last type spec including */&
+;;;       "\\("                           ; last type spec including */&
-                                ;       "[a-zA-Z0-9_:]+"
+;;;       "[a-zA-Z0-9_:]+"
-                                ;       "\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)"        ; either pointer/ref sign or whitespace
+;;;       "\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)"      ; either pointer/ref sign or whitespace
-                                ;       "\\)?"                            ; if there is a last type spec
+;;;       "\\)?"                                  ; if there is a last type spec
-                                ;       "\\("                         ; name; take that into the imenu entry
+;;;       "\\("                       ; name; take that into the imenu entry
-                                ;       "[a-zA-Z0-9_:~]+"                     ; member function, ctor or dtor...
+;;;       "[a-zA-Z0-9_:~]+"                   ; member function, ctor or dtor...
-                                ;                                       ; (may not contain * because then
+;;;                                     ; (may not contain * because then
-                                ;                                       ; "a::operator char*" would become "char*"!)
+;;;                                     ; "a::operator char*" would become "char*"!)
-                                ;       "\\|"
+;;;       "\\|"
-                                ;       "\\([a-zA-Z0-9_:~]*::\\)?operator"
+;;;       "\\([a-zA-Z0-9_:~]*::\\)?operator"
-                                ;       "[^a-zA-Z1-9_][^(]*"          ; ...or operator
+;;;       "[^a-zA-Z1-9_][^(]*"        ; ...or operator
-                                ;       " \\)"
+;;;       " \\)"
-                                ;       "[ \t]*([^)]*)[ \t\n]*;"        ; require ';' after
+;;;       "[ \t]*([^)]*)[ \t\n]*;"      ; require ';' after
-                                ;                                       ; the (...) Can't
+;;;                                     ; the (...) Can't
-                                ;                                       ; catch cases with () inside the parentheses
+;;;                                     ; catch cases with () inside the parentheses
-                                ;                                       ; surrounding the parameters
+;;;                                     ; surrounding the parameters
-                                ;                                       ; (like "int foo(int a=bar());"
+;;;                                     ; (like "int foo(int a=bar());"
-                                ;       )) 6)
+;;;       )) 6)
-                                ;    ("Struct"
+;;;    ("Struct"
-                                ;     (, (concat
+;;;     (, (concat
-                                ;        "^"                            ; beginning of line is required
+;;;      "^"                            ; beginning of line is required
-                                ;        "\\(static[ \t]+\\)?"          ; there may be static or const.
+;;;      "\\(static[ \t]+\\)?"          ; there may be static or const.
-                                ;        "\\(const[ \t]+\\)?"
+;;;      "\\(const[ \t]+\\)?"
-                                ;        "struct[ \t]+"
+;;;      "struct[ \t]+"
-                                ;        "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
+;;;      "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
-                                ;        "[ \t]*[{]"
+;;;      "[ \t]*[{]"
-                                ;        )) 3)
+;;;      )) 3)
-                                ;    ("Enum"
+;;;    ("Enum"
-                                ;     (, (concat
+;;;     (, (concat
-                                ;        "^"                            ; beginning of line is required
+;;;      "^"                            ; beginning of line is required
-                                ;        "\\(static[ \t]+\\)?"          ; there may be static or const.
+;;;      "\\(static[ \t]+\\)?"          ; there may be static or const.
-                                ;        "\\(const[ \t]+\\)?"
+;;;      "\\(const[ \t]+\\)?"
-                                ;        "enum[ \t]+"
+;;;      "enum[ \t]+"
-                                ;        "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
+;;;      "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
-                                ;        "[ \t]*[{]"
+;;;      "[ \t]*[{]"
-                                ;        )) 3)
+;;;      )) 3)
-                                ;    ("Union"
+;;;    ("Union"
-                                ;     (, (concat
+;;;     (, (concat
-                                ;        "^"                            ; beginning of line is required
+;;;      "^"                            ; beginning of line is required
-                                ;        "\\(static[ \t]+\\)?"          ; there may be static or const.
+;;;      "\\(static[ \t]+\\)?"          ; there may be static or const.
-                                ;        "\\(const[ \t]+\\)?"
+;;;      "\\(const[ \t]+\\)?"
-                                ;        "union[ \t]+"
+;;;      "union[ \t]+"
-                                ;        "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
+;;;      "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
-                                ;        "[ \t]*[{]"
+;;;      "[ \t]*[{]"
-                                ;        )) 3)
+;;;      )) 3)
    )
  "Imenu generic expression for C++ mode.  See `imenu-generic-expression'.")
author	Richard M. Stallman	2001-11-29 00:49:32 +0000
committer	Richard M. Stallman	2001-11-29 00:49:32 +0000
commit	bf5367b9c5c6bece7e66812fb53192cb376837cb (patch)
tree	5ef611bec316796d6c28b48a282e30008276c303
parent	ea8c55c919321f786865890f5bee6f0cad9f815a (diff)
download	emacs-bf5367b9c5c6bece7e66812fb53192cb376837cb.tar.gz emacs-bf5367b9c5c6bece7e66812fb53192cb376837cb.zip

diff --git a/lisp/obsolete/c-mode.el b/lisp/obsolete/c-mode.el index ae17183a2c2..7224f251ecf 100644 --- a/lisp/obsolete/c-mode.el +++ b/lisp/obsolete/c-mode.el
@@ -244,59 +244,59 @@ regardless of where in the line point is when the TAB command is used."
244	;; Example of generic expression for finding prototypes, structs, unions, enums.	244	;; Example of generic expression for finding prototypes, structs, unions, enums.
245	;; Uncomment if you want to find these too. It will be a bit slower gathering	245	;; Uncomment if you want to find these too. It will be a bit slower gathering
246	;; the indexes.	246	;; the indexes.
247	; ("Prototypes"	247	;;; ("Prototypes"
248	; (,	248	;;; (,
249	; (concat	249	;;; (concat
250	; "^" ; beginning of line is required	250	;;; "^" ; beginning of line is required
251	; "\\(template[ \t]<[^>]+>[ \t]\\)?" ; there may be a "template <...>"	251	;;; "\\(template[ \t]<[^>]+>[ \t]\\)?" ; there may be a "template <...>"
252	; "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; type specs; there can be no	252	;;; "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; type specs; there can be no
253	; "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; more than 3 tokens, right?	253	;;; "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; more than 3 tokens, right?
254		254
255	; "\\(" ; last type spec including */&	255	;;; "\\(" ; last type spec including */&
256	; "[a-zA-Z0-9_:]+"	256	;;; "[a-zA-Z0-9_:]+"
257	; "\\([ \t][&]+[ \t]*\\\|[ \t]+\\)" ; either pointer/ref sign or whitespace	257	;;; "\\([ \t][&]+[ \t]*\\\|[ \t]+\\)" ; either pointer/ref sign or whitespace
258	; "\\)?" ; if there is a last type spec	258	;;; "\\)?" ; if there is a last type spec
259	; "\\(" ; name; take that into the imenu entry	259	;;; "\\(" ; name; take that into the imenu entry
260	; "[a-zA-Z0-9_:~]+" ; member function, ctor or dtor...	260	;;; "[a-zA-Z0-9_:~]+" ; member function, ctor or dtor...
261	; ; (may not contain * because then	261	;;; ; (may not contain * because then
262	; ; "a::operator char" would become "char"!)	262	;;; ; "a::operator char" would become "char"!)
263	; "\\\|"	263	;;; "\\\|"
264	; "\\([a-zA-Z0-9_:~]*::\\)?operator"	264	;;; "\\([a-zA-Z0-9_:~]*::\\)?operator"
265	; "[^a-zA-Z1-9_][^(]*" ; ...or operator	265	;;; "[^a-zA-Z1-9_][^(]*" ; ...or operator
266	; " \\)"	266	;;; " \\)"
267	; "[ \t]([^)])[ \t\n]*;" ; require ';' after	267	;;; "[ \t]([^)])[ \t\n]*;" ; require ';' after
268	; ; the (...) Can't	268	;;; ; the (...) Can't
269	; ; catch cases with () inside the parentheses	269	;;; ; catch cases with () inside the parentheses
270	; ; surrounding the parameters	270	;;; ; surrounding the parameters
271	; ; (like "int foo(int a=bar());"	271	;;; ; (like "int foo(int a=bar());"
272	; )) 6)	272	;;; )) 6)
273	; ("Struct"	273	;;; ("Struct"
274	; (, (concat	274	;;; (, (concat
275	; "^" ; beginning of line is required	275	;;; "^" ; beginning of line is required
276	; "\\(static[ \t]+\\)?" ; there may be static or const.	276	;;; "\\(static[ \t]+\\)?" ; there may be static or const.
277	; "\\(const[ \t]+\\)?"	277	;;; "\\(const[ \t]+\\)?"
278	; "struct[ \t]+"	278	;;; "struct[ \t]+"
279	; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get	279	;;; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get
280	; "[ \t]*[{]"	280	;;; "[ \t]*[{]"
281	; )) 3)	281	;;; )) 3)
282	; ("Enum"	282	;;; ("Enum"
283	; (, (concat	283	;;; (, (concat
284	; "^" ; beginning of line is required	284	;;; "^" ; beginning of line is required
285	; "\\(static[ \t]+\\)?" ; there may be static or const.	285	;;; "\\(static[ \t]+\\)?" ; there may be static or const.
286	; "\\(const[ \t]+\\)?"	286	;;; "\\(const[ \t]+\\)?"
287	; "enum[ \t]+"	287	;;; "enum[ \t]+"
288	; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get	288	;;; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get
289	; "[ \t]*[{]"	289	;;; "[ \t]*[{]"
290	; )) 3)	290	;;; )) 3)
291	; ("Union"	291	;;; ("Union"
292	; (, (concat	292	;;; (, (concat
293	; "^" ; beginning of line is required	293	;;; "^" ; beginning of line is required
294	; "\\(static[ \t]+\\)?" ; there may be static or const.	294	;;; "\\(static[ \t]+\\)?" ; there may be static or const.
295	; "\\(const[ \t]+\\)?"	295	;;; "\\(const[ \t]+\\)?"
296	; "union[ \t]+"	296	;;; "union[ \t]+"
297	; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get	297	;;; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get
298	; "[ \t]*[{]"	298	;;; "[ \t]*[{]"
299	; )) 3)	299	;;; )) 3)
300	)	300	)
301	"Imenu generic expression for C mode. See `imenu-generic-expression'.")	301	"Imenu generic expression for C mode. See `imenu-generic-expression'.")
302		302


diff --git a/lisp/obsolete/cplus-md.el b/lisp/obsolete/cplus-md.el index 7b7e3c4d26b..5eb219da6b4 100644 --- a/lisp/obsolete/cplus-md.el +++ b/lisp/obsolete/cplus-md.el
@@ -211,59 +211,59 @@ list. Nil indicates to just after the paren."
211	;; Example of generic expression for finding prototypes, structs, unions, enums.	211	;; Example of generic expression for finding prototypes, structs, unions, enums.
212	;; Uncomment if you want to find these too. It will be a bit slower gathering	212	;; Uncomment if you want to find these too. It will be a bit slower gathering
213	;; the indexes.	213	;; the indexes.
214	; ("Prototypes"	214	;;; ("Prototypes"
215	; (,	215	;;; (,
216	; (concat	216	;;; (concat
217	; "^" ; beginning of line is required	217	;;; "^" ; beginning of line is required
218	; "\\(template[ \t]<[^>]+>[ \t]\\)?" ; there may be a "template <...>"	218	;;; "\\(template[ \t]<[^>]+>[ \t]\\)?" ; there may be a "template <...>"
219	; "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; type specs; there can be no	219	;;; "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; type specs; there can be no
220	; "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; more than 3 tokens, right?	220	;;; "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; more than 3 tokens, right?
221		221
222	; "\\(" ; last type spec including */&	222	;;; "\\(" ; last type spec including */&
223	; "[a-zA-Z0-9_:]+"	223	;;; "[a-zA-Z0-9_:]+"
224	; "\\([ \t][&]+[ \t]*\\\|[ \t]+\\)" ; either pointer/ref sign or whitespace	224	;;; "\\([ \t][&]+[ \t]*\\\|[ \t]+\\)" ; either pointer/ref sign or whitespace
225	; "\\)?" ; if there is a last type spec	225	;;; "\\)?" ; if there is a last type spec
226	; "\\(" ; name; take that into the imenu entry	226	;;; "\\(" ; name; take that into the imenu entry
227	; "[a-zA-Z0-9_:~]+" ; member function, ctor or dtor...	227	;;; "[a-zA-Z0-9_:~]+" ; member function, ctor or dtor...
228	; ; (may not contain * because then	228	;;; ; (may not contain * because then
229	; ; "a::operator char" would become "char"!)	229	;;; ; "a::operator char" would become "char"!)
230	; "\\\|"	230	;;; "\\\|"
231	; "\\([a-zA-Z0-9_:~]*::\\)?operator"	231	;;; "\\([a-zA-Z0-9_:~]*::\\)?operator"
232	; "[^a-zA-Z1-9_][^(]*" ; ...or operator	232	;;; "[^a-zA-Z1-9_][^(]*" ; ...or operator
233	; " \\)"	233	;;; " \\)"
234	; "[ \t]([^)])[ \t\n]*;" ; require ';' after	234	;;; "[ \t]([^)])[ \t\n]*;" ; require ';' after
235	; ; the (...) Can't	235	;;; ; the (...) Can't
236	; ; catch cases with () inside the parentheses	236	;;; ; catch cases with () inside the parentheses
237	; ; surrounding the parameters	237	;;; ; surrounding the parameters
238	; ; (like "int foo(int a=bar());"	238	;;; ; (like "int foo(int a=bar());"
239	; )) 6)	239	;;; )) 6)
240	; ("Struct"	240	;;; ("Struct"
241	; (, (concat	241	;;; (, (concat
242	; "^" ; beginning of line is required	242	;;; "^" ; beginning of line is required
243	; "\\(static[ \t]+\\)?" ; there may be static or const.	243	;;; "\\(static[ \t]+\\)?" ; there may be static or const.
244	; "\\(const[ \t]+\\)?"	244	;;; "\\(const[ \t]+\\)?"
245	; "struct[ \t]+"	245	;;; "struct[ \t]+"
246	; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get	246	;;; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get
247	; "[ \t]*[{]"	247	;;; "[ \t]*[{]"
248	; )) 3)	248	;;; )) 3)
249	; ("Enum"	249	;;; ("Enum"
250	; (, (concat	250	;;; (, (concat
251	; "^" ; beginning of line is required	251	;;; "^" ; beginning of line is required
252	; "\\(static[ \t]+\\)?" ; there may be static or const.	252	;;; "\\(static[ \t]+\\)?" ; there may be static or const.
253	; "\\(const[ \t]+\\)?"	253	;;; "\\(const[ \t]+\\)?"
254	; "enum[ \t]+"	254	;;; "enum[ \t]+"
255	; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get	255	;;; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get
256	; "[ \t]*[{]"	256	;;; "[ \t]*[{]"
257	; )) 3)	257	;;; )) 3)
258	; ("Union"	258	;;; ("Union"
259	; (, (concat	259	;;; (, (concat
260	; "^" ; beginning of line is required	260	;;; "^" ; beginning of line is required
261	; "\\(static[ \t]+\\)?" ; there may be static or const.	261	;;; "\\(static[ \t]+\\)?" ; there may be static or const.
262	; "\\(const[ \t]+\\)?"	262	;;; "\\(const[ \t]+\\)?"
263	; "union[ \t]+"	263	;;; "union[ \t]+"
264	; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get	264	;;; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get
265	; "[ \t]*[{]"	265	;;; "[ \t]*[{]"
266	; )) 3)	266	;;; )) 3)
267	)	267	)
268	"Imenu generic expression for C++ mode. See `imenu-generic-expression'.")	268	"Imenu generic expression for C++ mode. See `imenu-generic-expression'.")
269		269