xemacs-beta: lisp/cc-mode/cc-cmds.el comparison

comparison lisp/cc-mode/cc-cmds.el @ 171:929b76928fce r20-3b12

Import from CVS: tag r20-3b12

author	cvs
date	Mon, 13 Aug 2007 09:47:52 +0200
parents	5a88923fcbfe
children	8eaf7971accc

comparison

equal deleted inserted replaced

-:98a42ee61975
+:929b76928fce
 ;; Authors:    1992-1997 Barry A. Warsaw
 ;;             1987 Dave Detlefs and Stewart Clamen
 ;;             1985 Richard M. Stallman
 ;; Maintainer: cc-mode-help@python.org
 ;; Created:    22-Apr-1997 (split from cc-mode.el)
-;; Version:    5.11
+;; Version:    5.12
 ;; Keywords:   c languages oop
 ;; This file is part of GNU Emacs.
 ;; GNU Emacs is free software; you can redistribute it and/or modify
 ;; You should have received a copy of the GNU General Public License
 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 ;; Boston, MA 02111-1307, USA.
-(eval-when-compile
-(load-file "./cc-engine.el"))
-;; Utilities
-(defsubst c-update-modeline ()
-;; set the c-auto-hungry-string for the correct designation on the modeline
-(setq c-auto-hungry-string
-	(if c-auto-newline
-	    (if c-hungry-delete-key "/ah" "/a")
-	  (if c-hungry-delete-key "/h" nil)))
-(force-mode-line-update))
 (defun c-calculate-state (arg prevstate)
 ;; Calculate the new state of PREVSTATE, t or nil, based on arg. If
 ;; arg is nil or zero, toggle the state. If arg is negative, turn
 ;; the state off, and if arg is positive, turn the state on
 (if (or (not arg)
 	  (zerop (setq arg (prefix-numeric-value arg))))
 (not prevstate)
 (> arg 0)))
 ;; Auto-newline and hungry-delete
 (defun c-toggle-auto-state (arg)
 "Toggle auto-newline feature.
 Optional numeric ARG, if supplied turns on auto-newline when positive,
 turns it off when negative, and just toggles it when zero.
 	    ;; be most disruptive. we'll blink it ourselves later on
 	    (old-blink-paren blink-paren-function)
 	    blink-paren-function
 	    (insertion-point (point))
 	    delete-temp-newline
-	    (preserve-p (= 32 (char-syntax (preceding-char))))
+	    (preserve-p (eq 32 (char-syntax (char-before))))
 	    ;; shut this up too
 	    (c-echo-syntactic-information-p nil)
 	    (syntax (progn
 		      ;; only insert a newline if there is
 		      ;; non-whitespace behind us
 	      ;; faster than recalculating the state in many cases
 	      (save-excursion
 		(save-restriction
 		  (narrow-to-region here (point))
 		  (if (and (c-safe (progn (backward-up-list -1) t))
-			   (memq (preceding-char) '(?\) ?}))
+			   (memq (char-before) '(?\) ?}))
 			   (progn (widen)
 				  (c-safe (progn (forward-sexp -1) t))))
 		      (setq c-state-cache
 			    (c-hack-state (point) 'open c-state-cache))
 		    (if (and (car c-state-cache)
 	      (pos (- (point-max) (point)))
 	      mbeg mend)
 	  ;; clean up empty defun braces
 	  (if (and c-auto-newline
 		   (memq 'empty-defun-braces c-cleanup-list)
-		   (= last-command-char ?\})
+		   (eq last-command-char ?\})
 		   (c-intersect-lists '(defun-close class-close inline-close)
 				      syntax)
 		   (progn
 		     (forward-char -1)
 		     (skip-chars-backward " \t\n")
-		     (= (preceding-char) ?\{))
+		     (eq (char-before) ?\{))
 		   ;; make sure matching open brace isn't in a comment
 		   (not (c-in-literal)))
 	      (delete-region (point) (1- here)))
 	  ;; clean up brace-else-brace
 	  (if (and c-auto-newline
 		   (memq 'brace-else-brace c-cleanup-list)
-		   (= last-command-char ?\{)
+		   (eq last-command-char ?\{)
 		   (re-search-backward "}[ \t\n]*else[ \t\n]*{" nil t)
 		   (progn
 		     (setq mbeg (match-beginning 0)
 			   mend (match-end 0))
 		     (= mend here))
 		(delete-region mbeg mend)
 		(insert "} else {")))
 	  ;; clean up brace-elseif-brace
 	  (if (and c-auto-newline
 		   (memq 'brace-elseif-brace c-cleanup-list)
-		   (= last-command-char ?\{)
+		   (eq last-command-char ?\{)
 		   (re-search-backward "}[ \t\n]*else[ \t\n]+if[ \t\n]*" nil t)
 		   (save-excursion
 		     (goto-char (match-end 0))
 		     (c-safe (forward-sexp 1))
 		     (skip-chars-forward " \t\n")
 	(if (memq 'after newlines)
 	    (progn
 	      (newline)
 	      ;; update on c-state-cache
 	      (let* ((bufpos (- (point) 2))
-		     (which (if (= (char-after bufpos) ?{) 'open 'close))
+		     (which (if (eq (char-after bufpos) ?{) 'open 'close))
 		     (c-state-cache (c-hack-state bufpos which c-state-cache)))
 		(c-indent-line))))
 	;; blink the paren
-	(and (= last-command-char ?\})
+	(and (eq last-command-char ?\})
 	     old-blink-paren
 	     (save-excursion
 	       (c-backward-syntactic-ws safepos)
 	       (funcall old-blink-paren)))
 	))))
 construct, and we are on a comment-only-line, indent line as comment.
 If numeric ARG is supplied or point is inside a literal, indentation
 is inhibited."
 (interactive "P")
 (let ((indentp (and (not arg)
-		      (= (preceding-char) ?/)
+		      (eq (char-before) ?/)
-		      (= last-command-char ?/)
+		      (eq last-command-char ?/)
 		      (not (c-in-literal))))
 	;; shut this up
 	(c-echo-syntactic-information-p nil))
 (self-insert-command (prefix-numeric-value arg))
 (if indentp
 (self-insert-command (prefix-numeric-value arg))
 ;; if we are in a literal, or if arg is given do not re-indent the
 ;; current line, unless this star introduces a comment-only line.
 (if (and (not arg)
 	   (memq (c-in-literal) '(c))
-	   (= (preceding-char) ?*)
+	   (eq (char-before) ?*)
 	   (save-excursion
 	     (forward-char -1)
 	     (skip-chars-backward "*")
-	     (if (= (preceding-char) ?/)
+	     (if (eq (char-before) ?/)
 		 (forward-char -1))
 	     (skip-chars-backward " \t")
 	     (bolp)))
 ;; shut this up
 (let (c-echo-syntactic-information-p)
 ;; only if c-auto-newline is turned on
 (if (not c-auto-newline) nil
 	;; clean ups
 	(let ((pos (- (point-max) (point))))
 	  (if (and (or (and
-			(= last-command-char ?,)
+			(eq last-command-char ?,)
 			(memq 'list-close-comma c-cleanup-list))
 		       (and
-			(= last-command-char ?\;)
+			(eq last-command-char ?\;)
 			(memq 'defun-close-semi c-cleanup-list)))
 		   (progn
 		     (forward-char -1)
 		     (skip-chars-backward " \t\n")
-		     (= (preceding-char) ?}))
+		     (eq (char-before) ?}))
 		   ;; make sure matching open brace isn't in a comment
 		   (not (c-in-literal lim)))
 	      (delete-region (point) here))
 	  (goto-char (- (point-max) pos)))
 	;; re-indent line
 (self-insert-command (prefix-numeric-value arg))
 (let ((pos (- (point-max) (point)))
 	    (here (point)))
 	(if (and c-auto-newline
 		 (memq 'scope-operator c-cleanup-list)
-		 (= (preceding-char) ?:)
+		 (eq (char-before) ?:)
 		 (progn
 		   (forward-char -1)
 		   (skip-chars-backward " \t\n")
-		   (= (preceding-char) ?:))
+		   (eq (char-before) ?:))
 		 (not (c-in-literal))
-		 (not (= (char-after (- (point) 2)) ?:)))
+		 (not (eq (char-after (- (point) 2)) ?:)))
 	    (delete-region (point) (1- here)))
 	(goto-char (- (point-max) pos)))
 ;; lets do some special stuff with the colon character
 (setq syntax (c-guess-basic-syntax)
 	    ;; some language elements can only be determined by
 The line will also not be re-indented if a numeric argument is
 supplied, or point is inside a literal."
 (interactive "P")
 (let ((indentp (and (not arg)
-		      (= (preceding-char) last-command-char)
+		      (eq (char-before) last-command-char)
 		      (not (c-in-literal))))
 	;; shut this up
 	(c-echo-syntactic-information-p nil))
 (self-insert-command (prefix-numeric-value arg))
 (if indentp
 		       ;; try to be smarter about finding the range of
 		       ;; lines to indent. skip all following
 		       ;; whitespace. failing that, try to find any
 		       ;; opening brace on the current line
 		       (skip-chars-forward " \t\n")
-		       (if (memq (following-char) '(?\( ?\[ ?\{))
+		       (if (memq (char-after) '(?\( ?\[ ?\{))
 			   (point)
 			 (let ((state (parse-partial-sexp (point)
 							  (c-point 'eol))))
 			   (and (nth 1 state)
 				(goto-char (nth 1 state))
-				(memq (following-char) '(?\( ?\[ ?\{))
+				(memq (char-after) '(?\( ?\[ ?\{))
 				(point)))))))
 	  ;; find balanced expression end
 	  (setq end (and (c-safe (progn (forward-sexp 1) t))
 			 (point-marker)))
 	  ;; sanity check
 	(goto-char brace)
 (beginning-of-defun))
 ;; if we're sitting at b-o-b, it might be because there was no
 ;; least enclosing brace and we were sitting on the defun's open
 ;; brace.
-(if (and (bobp) (not (= (following-char) ?\{)))
+(if (and (bobp) (not (eq (char-after) ?\{)))
 	(goto-char here))
 ;; if defun-prompt-regexp is non-nil, b-o-d might not leave us at
 ;; the open brace. I consider this an Emacs bug.
 (and (boundp 'defun-prompt-regexp)
 	 defun-prompt-regexp
 		       (set-marker sexpend nil))
 		  (forward-line 1)
 		  (setq fence (point))))))
 	(set-marker endmark nil)
 	(c-progress-fini 'c-indent-region)
+	(c-echo-parsing-error)
 	))))
 (defun c-mark-function ()
 "Put mark at end of a C, C++, or Objective-C defun, point at beginning."
 (interactive)
 (setq brace (car state))
 (if (consp brace)
 	  (goto-char (cdr brace))
 	(goto-char brace))
 (setq state (cdr state)))
-(if (= (following-char) ?{)
+(if (eq (char-after) ?{)
 	(progn
 	  (forward-line -1)
 	  (while (not (or (bobp)
 			  (looking-at "[ \t]*$")))
 	    (forward-line -1)))
 (move-marker endmark to)
 ;; Compute the smallest column number past the ends of all the lines.
 (if (not delete-flag)
 (while (< (point) to)
 (end-of-line)
-(if (= (preceding-char) ?\\)
+(if (eq (char-before) ?\\)
 (progn (forward-char -1)
 (skip-chars-backward " \t")))
 (setq column (max column (1+ (current-column))))
 (forward-line 1)))
 ;; Adjust upward to a tab column, if that doesn't push past the margin.
 (move-marker endmark nil)))
 (c-keep-region-active))
 (defun c-append-backslash (column)
 (end-of-line)
-;; Note that "\\\\" is needed to get one backslash.
+(if (eq (char-before) ?\\)
-(if (= (preceding-char) ?\\)
 (progn (forward-char -1)
 (delete-horizontal-space)
 (indent-to column))
 (indent-to column)
 (insert "\\")))
 			      (beginning-of-line)
 			      (skip-chars-forward " \t*" (c-point 'eol))
 			      ;; kludge alert, watch out for */, in
 			      ;; which case fill-prefix should *not*
 			      ;; be "*"!
-			      (if (and (= (following-char) ?/)
+			      (if (and (eq (char-after) ?/)
-				       (= (preceding-char) ?*))
+				       (eq (char-before) ?*))
 				  (forward-char -1))
 			      (point)))
 			 ;; If the comment is only one line followed
 			 ;; by a blank line, calling move-to-column

Mercurial > hg > xemacs-beta

comparison lisp/cc-mode/cc-cmds.el @ 171:929b76928fce r20-3b12