emacs: lisp/obsolete/cplus-md.el comparison

comparison lisp/obsolete/cplus-md.el @ 41609:f1391a41ece3

fixed {}() quoting

author	Sam Steingold <sds@gnu.org>
date	Tue, 27 Nov 2001 17:00:12 +0000
parents	45db352a0971
children	5223683cd329

comparison

equal deleted inserted replaced

-:45db352a0971
+:f1391a41ece3
 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 ;; Boston, MA 02111-1307, USA.
 ;;; Commentary:
 ;; 1987 Dave Detlefs  <dld@cs.cmu.edu>
 ;; and  Stewart Clamen <clamen@cs.cmu.edu>.
 ;; Done by fairly faithful modification of:
 ;;; Change Log:
 ;; Feb, 1990 (Dave Detlefs, dld@cs.cmu.edu)
 ;;   Fixed electric-c++-terminator to handle double colons, at the
 ;;   request of John Hagerman.
 ;;
 ;; Jan, 1990 (Doug Lea, dl@oswego.edu)
 ;;   Replaced c++-comment-region and c++-uncomment-region with
 ;;     versions from Igor Metz that avoid potential infinite loops.
 ;;
 ;; Oct, 1989 (Dave Detlefs, dld@cs.cmu.edu)
 ;;   Added contribution from Igor Metz <metz@iam.unibe.ch>:
 ;;     functions c++-comment-region and c++-uncomment-region and
 ;;     corresponding key-binding.
 ;;   Also fixed bug in indentation of second line after an empty
 ;;   arglist with empty-arglist non-null.
 ;;
 ;; Sept, 1989 (Glen Ditchfield, gjditchfield@violet.uwaterloo.ca):
 ;;   Textual changes to more closely imitate Emacs 18.55's c-mode.
 ;;   Fixed handling of "default:", where ":" was the last character in the
 ;;   buffer.  Fixed indentation of comments starting in column 0, and when
 ;;   previous line contained more than one comment start string.  Fixed
 ,(concat
 "^"                      ; beginning of line is required
 "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
 "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; type specs; there can be no
 "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; more than 3 tokens, right?
 "\\("                    ; last type spec including */&
 "[a-zA-Z0-9_:]+"
 "\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)" ; either pointer/ref sign or whitespace
 "\\)?"                   ; if there is a last type spec
 "\\("                    ; name; take that into the imenu entry
 "[a-zA-Z0-9_:~]+"        ; member function, ctor or dtor...
 ; (may not contain * because then
 ; "a::operator char*" would become "char*"!)
 "\\|"
 "\\([a-zA-Z0-9_:~]*::\\)?operator"
 "[^a-zA-Z1-9_][^(]*"     ; ...or operator
 " \\)"
 "[ \t]*([^)]*)[ \t\n]*[^	      ;]" ; require something other than a ; after
 ; the (...) to avoid prototypes.  Can't
 ; catch cases with () inside the parentheses
 ; surrounding the parameters
 ; (like "int foo(int a=bar()) {...}"
 ) 6)
 ("Class"
 ,(concat
 "^"                      ; beginning of line is required
 "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
 "class[ \t]+"
 "\\([a-zA-Z0-9_]+\\)"    ; this is the string we want to get
 "[ \t]*[:{]"
 ) 2)
 ;; 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"
 ;     (,
 ;      (concat
 ;       "^"				  ; beginning of line is required
 ;       "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
 ;       "\\([a-zA-Z0-9_:]+[ \t]+\\)?"	  ; type specs; there can be no
 ;       "\\([a-zA-Z0-9_:]+[ \t]+\\)?"	  ; more than 3 tokens, right?
 ;       "\\("				  ; last type spec including */&
 ;       "[a-zA-Z0-9_:]+"
 ;       "\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)"	  ; either pointer/ref sign or whitespace
 ;       "\\)?"				  ; if there is a last type spec
 ;       "\\("			      ; name; take that into the imenu entry
 ;       "[a-zA-Z0-9_:~]+"		      ; member function, ctor or dtor...
 ;					; (may not contain * because then
 ;					; "a::operator char*" would become "char*"!)
 ;       "\\|"
 ;       "\\([a-zA-Z0-9_:~]*::\\)?operator"
 ;       "[^a-zA-Z1-9_][^(]*"	      ; ...or operator
 ;       " \\)"
 ;       "[ \t]*([^)]*)[ \t\n]*;" 	; require ';' after
 ;					; the (...) Can't
 ;					; catch cases with () inside the parentheses
 ;					; surrounding the parameters
 ;					; (like "int foo(int a=bar());"
 ;       )) 6)
 ;    ("Struct"
 ;     (, (concat
 ;	 "^"				; beginning of line is required
 ;	 "\\(static[ \t]+\\)?"		; there may be static or const.
 ;	 "\\(const[ \t]+\\)?"
 		  (setq indent (save-excursion
 				 (c-backward-to-start-of-if)
 				 (current-indentation))))
 		 ((looking-at "friend\[ \t]")
 		  (setq indent (+ indent c++-friend-offset)))
-		 ((= (following-char) ?})
+		 ((= (following-char) ?\})
 		  (setq indent (- indent c-indent-level)))
-		 ((= (following-char) ?{)
+		 ((= (following-char) ?\{)
 		  (setq indent (+ indent c-brace-offset))))))
 (skip-chars-forward " \t")
 (setq shift-amt (- indent (current-column)))
 (if (zerop shift-amt)
 	(if (> (- (point-max) pos) (point))
 	     ;; (2) the previous line begins with a colon,
 	     ;; in which case this is the second line of member inits.
 	     ;; It is assumed that arg decls and member inits are not mixed.
 	     (goto-char indent-point)
 	     (skip-chars-forward " \t")
-	     (if (= (following-char) ?{)
+	     (if (= (following-char) ?\{)
 		 0   ; Unless it starts a function body
 	       (c++-backward-to-noncomment (or parse-start (point-min)))
 	       (if (= (preceding-char) ?\))
 		   (progn		; first arg decl or member init
 		     (goto-char indent-point)
 		     (if (= (following-char) ?:)
 			 c++-member-init-indent
 		       c-argdecl-indent))
 		 (if (= (preceding-char) ?\;)
 		     (backward-char 1))
-		 (if (= (preceding-char) ?})
+		 (if (= (preceding-char) ?\})
 		     0
 		   (if (= (preceding-char) ?\))
 		       (forward-list -1))
 		   (beginning-of-line)	; continued arg decls or member inits
 		   (skip-chars-forward " \t")
 			   (forward-char 1)
 			   (skip-chars-forward " \t")
 			   (current-column)))
 		     (current-indentation)))
 		 )))
-	    ((/= (char-after containing-sexp) ?{)
+	    ((/= (char-after containing-sexp) ?\{)
 	     ;; line is expression, not statement:
 	     ;; indent to just after the surrounding open -- unless
 	     ;; empty arg list, in which case we do what
 	     ;; c++-empty-arglist-indent says to do.
 	     (if (and c++-empty-arglist-indent
 		      ;; as a continuation.  It is probably the
 		      ;; end of an enum type declaration.
 		      (save-excursion
 			(goto-char indent-point)
 			(skip-chars-forward " \t")
-			(not (= (following-char) ?}))))
+			(not (= (following-char) ?\}))))
 		 ;; This line is continuation of preceding line's statement;
 		 ;; indent  c-continued-statement-offset  more than the
 		 ;; previous line of the statement.
 		 (progn
 		   (c-backward-to-start-of-continued-exp containing-sexp)
 		   (+ c-continued-statement-offset (current-column)
 (if (save-excursion (goto-char indent-point)
 					  (skip-chars-forward " \t")
-					  (eq (following-char) ?{))
+					  (eq (following-char) ?\{))
 			  c-continued-brace-offset 0)))
 	       ;; This line starts a new statement.
 	       ;; Position following last unclosed open.
 	       (goto-char containing-sexp)
 	       ;; Is line first statement after an open-brace?
 					      (setq colon-line-end (point)))
 			      (search-forward ":"))))
 		     ;; The first following code counts
 		     ;; if it is before the line we want to indent.
 		     (and (< (point) indent-point)
 			  (-
 			   (if (> colon-line-end (point))
 			       (- (current-indentation) c-label-offset)
 			     (current-column))
 			   ;; If prev stmt starts with open-brace, that
 			   ;; open brace was offset by c-brace-offset.
 		    ;; possibly a different line
 		    (progn
 		      (if (eq (preceding-char) ?\))
 			  (forward-sexp -1))
 		      ;; Get initial indentation of the line we are on.
-		      (current-indentation)))))))))))
+		      (current-indentation))))))))))
 (defun c++-backward-to-noncomment (lim)
 (let (opoint stop)
 (while (not stop)
 (skip-chars-backward " \t\n\r\f" lim)
 		;; Lines inside parens are handled specially.
 		nil
 	      ;; Just started a new nesting level.
 	      ;; Compute the standard indent for this level.
 	      (let (val)
-		(if (= (char-after (car contain-stack)) ?{)
+		(if (= (char-after (car contain-stack)) ?\{)
 		    (save-excursion
 		      (goto-char (car contain-stack))
 		      (setq val (calculate-c-indent-after-brace)))
 		  (setq val (calculate-c++-indent
 			     (if (car indent-stack)
 		(if (re-search-forward comment-start-skip
 				       (save-excursion (end-of-line)
 						       (point)) t)
 		    (progn
 		      (indent-for-comment)
-		      (beginning-of-line)))))))))))
+		      (beginning-of-line))))))))))
 (defun fill-c++-comment ()
 "Fill a comment contained in consecutive lines containing point.
 The fill lines remain a comment."
 (interactive)
 ;;; determines which to use; the default is the weak one.
 ;; (defvar c++-match-header-strongly nil
 ;;   "*If nil, use `c++-defun-header-weak' to identify beginning of definitions.
 ;; If non-nil, use `c++-defun-header-strong'.")
 ;;
 ;; (defvar c++-defun-header-strong-struct-equivs "\\(class\\|struct\\|enum\\)"
 ;;   "Regexp to match names of structure declaration blocks in C++.")
 ;;
 ;; (defconst c++-defun-header-strong
 ;;   (let*
 ;;       (; valid identifiers
 ;;        ;; There's a real weirdness here -- if I switch the below
 ;;        (id "\\(\\w\\|_\\)+")
 ;;        ;; to be
 ;;        ;; (id "\\(_\\|\\w\\)+")
 ;;        ;; things no longer work right.  Try it and see!
 ;;
 ;;        ; overloadable operators
 ;;        (op-sym1
 ;; 	 "[-+*/%^&|~!=<>]\\|[-+*/%^&|<>=!]=\\|<<=?\\|>>=?")
 ;;        (op-sym2
 ;; 	 "&&\\|||\\|\\+\\+\\|--\\|()\\|\\[\\]")
 ;;        (op-sym (concat "\\(" op-sym1 "\\|" op-sym2 "\\)"))
 ;;        ; whitespace
 ;;        (middle "[^\\*]*\\(\\*+[^/\\*][^\\*]*\\)*")
 ;;        (c-comment (concat "/\\*" middle "\\*+/"))
 ;;        (wh (concat "\\(\\s \\|\n\\|//.*$\\|" c-comment "\\)"))
 ;;        (cs-header (concat
 ;; 		    c++-defun-header-strong-struct-equivs
 ;; 		    wh-nec id wh-opt inherit "?" wh-opt "{")))
 ;;     (concat "^\\(" func-header "\\|" cs-header "\\)"))
 ;;   "Strongly-defined regexp to match beginning of structure or function def.")
 ;;
 ;;
 ;; ;; This part has to do with recognizing defuns.
 ;;
 ;; ;; The weak convention we will use is that a defun begins any time
 ;; ;; there is a left curly brace, or some identifier on the left margin,
 ;; ;; followed by a left curly somewhere on the line.  (This will also
 ;; ;; incorrectly match some continued strings, but this is after all
 ;; ;; just a weak heuristic.)  Suggestions for improvement (short of the
 ;; ;; strong scheme shown above) are welcomed.
 ;;
 ;; (defconst c++-defun-header-weak "^{\\|^[_a-zA-Z].*{"
 ;;   "Weakly-defined regexp to match beginning of structure or function def.")
 ;;
 ;; (defun c++-beginning-of-defun (arg)
 ;;   (interactive "p")
 ;;   (let ((c++-defun-header (if c++-match-header-strongly
 ;; 			      c++-defun-header-strong
 ;; 			    c++-defun-header-weak)))
 ;; 	  (t
 ;; 	    (if (and (looking-at c++-defun-header) (not (bobp)))
 ;; 		(forward-char (if (< arg 0) 1 -1)))
 ;; 	    (and (re-search-backward c++-defun-header nil 'move (or arg 1))
 ;; 		 (goto-char (match-beginning 0)))))))
 ;;
 ;;
 ;; (defun c++-end-of-defun (arg)
 ;;   (interactive "p")
 ;;   (let ((c++-defun-header (if c++-match-header-strongly
 ;; 			      c++-defun-header-strong
 ;; 			    c++-defun-header-weak)))
 ;;     (if (and (eobp) (> arg 0))
 ;; 	nil
 ;;       (if (and (> arg 0) (looking-at c++-defun-header)) (forward-char 1))
 ;;       (let ((pos (point)))
 ;; 	(c++-beginning-of-defun
 ;; 	  (if (< arg 0)
 ;; 	      (- (- arg (if (eobp) 0 1)))
 ;; 	    arg))
 ;; 	(if (and (< arg 0) (bobp))
 ;; 	    t
 ;; 	  (if (re-search-forward c++-defun-header nil 'move)
 ;; 	      (progn (forward-char -1)
 ;; 		     (forward-sexp)
 ;; 		     (beginning-of-line 2)))
 ;; 	  (if (and (= pos (point))
 ;; 		   (re-search-forward c++-defun-header nil 'move))
 ;; 	      (c++-end-of-defun 1))))
 ;;       t)))
 ;;
 ;; (defun c++-indent-defun ()
 ;;   "Indents the current function definition, struct or class declaration."
 ;;   (interactive)
 ;;   (let ((restore (point)))
 ;;     (c++-end-of-defun 1)

Mercurial > emacs

comparison lisp/obsolete/cplus-md.el @ 41609:f1391a41ece3