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

comparison lisp/cc-mode/cc-align.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	2d532a89d707

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"))
+(require 'cc-defs)
+(require 'cc-vars)
-(defsubst c-langelem-col (langelem &optional preserve-point)
+(require 'cc-engine)
-;; convenience routine to return the column of langelem's relpos.
+(require 'cc-langs))
-;; Leaves point at the relpos unless preserve-point is non-nil.
-(let ((here (point)))
-(goto-char (cdr langelem))
-(prog1 (current-column)
-(if preserve-point
-	  (goto-char here))
-)))
 ;; Standard indentation line-ups
 (defun c-lineup-arglist (langelem)
 ;; lineup the current arglist line with the arglist appearing just
 		 (forward-char 1)
 		 (c-forward-syntactic-ws)
 		 (- (current-column) langelem-col))
 	(goto-char containing-sexp)
 	(or (eolp)
-	    (not (memq (following-char) '(?{ ?\( )))
+	    (not (memq (char-after) '(?{ ?\( )))
 	    (let ((eol (c-point 'eol))
 		  (here (progn
 			  (forward-char 1)
 			  (skip-chars-forward " \t")
 			  (point))))
 ))))
 (defun c-lineup-runin-statements (langelem)
 ;; line up statements in coding standards which place the first
 ;; statement on the same line as the block opening brace.
-(if (= (char-after (cdr langelem)) ?{)
+(if (eq (char-after (cdr langelem)) ?{)
 (save-excursion
 	(let ((langelem-col (c-langelem-col langelem)))
 	  (forward-char 1)
 	  (skip-chars-forward " \t")
 	  (- (current-column) langelem-col)))
 ;; line up math statement-cont after the equals
 (save-excursion
 (let ((equalp (save-excursion
 		    (goto-char (c-point 'boi))
 		    (skip-chars-forward "^=" (c-point 'eol))
-		    (and (= (following-char) ?=)
+		    (and (eq (char-after) ?=)
 			 (- (point) (c-point 'boi)))))
 	  (langelem-col (c-langelem-col langelem))
 	  donep)
 (while (and (not donep)
 		  (< (point) (c-point 'eol)))
 	(skip-chars-forward "^=" (c-point 'eol))
 	(if (c-in-literal (cdr langelem))
 	    (forward-char 1)
 	  (setq donep t)))
-(if (/= (following-char) ?=)
+(if (not (eq (char-after) ?=))
 	  ;; there's no equal sign on the line
 	  c-basic-offset
 	;; calculate indentation column after equals and ws, unless
 	;; our line contains an equals sign
 	(if (not equalp)
 ;; with it.
 (save-excursion
 (let* ((extra (save-excursion
 		    (back-to-indentation)
 		    (c-backward-syntactic-ws (cdr langelem))
-		    (if (= (preceding-char) ?:)
+		    (if (eq (char-before) ?:)
 			(- c-basic-offset)
 		      0)))
 	   (open-bracket-pos (cdr langelem))
 (open-bracket-col (progn
 			       (goto-char open-bracket-pos)
 	   (eol (c-point 'eol))
 	   (relpos (cdr langelem))
 	   (first-col-column (progn
 			       (goto-char relpos)
 			       (skip-chars-forward "^:" eol)
-			       (and (= (following-char) ?:)
+			       (and (eq (char-after) ?:)
 				    (current-column)))))
 (if (not first-col-column)
 	  c-basic-offset
 	(goto-char here)
 	(skip-chars-forward "^:" eol)
-	(if (= (following-char) ?:)
+	(if (eq (char-after) ?:)
 	    (+ curcol (- first-col-column (current-column)))
 	  c-basic-offset)))))
 (defun c-lineup-ObjC-method-args-2 (langelem)
 ;; Line up the colons that separate args. This is done trying to
 	   (curcol (progn (goto-char here) (current-column)))
 	   (eol (c-point 'eol))
 	   (relpos (cdr langelem))
 	   (prev-col-column (progn
 			      (skip-chars-backward "^:" relpos)
-			      (and (= (preceding-char) ?:)
+			      (and (eq (char-before) ?:)
 				   (- (current-column) 1)))))
 (if (not prev-col-column)
 	  c-basic-offset
 	(goto-char here)
 	(skip-chars-forward "^:" eol)
-	(if (= (following-char) ?:)
+	(if (eq (char-after) ?:)
 	    (+ curcol (- prev-col-column (current-column)))
 	  c-basic-offset)))))
 (defun c-snug-do-while (syntax pos)
 "Dynamically calculate brace hanginess for do-while statements.
 (save-excursion
 (let (langelem)
 (if (and (eq syntax 'block-close)
 	       (setq langelem (assq 'block-close c-syntactic-context))
 	       (progn (goto-char (cdr langelem))
-		      (if (= (following-char) ?{)
+		      (if (eq (char-after) ?{)
 			  (c-safe (forward-sexp -1)))
 		      (looking-at "\\<do\\>[^_]")))
 	  '(before)
 	'(before after)))))
 inserted inside a parenthesis list, no newline is added otherwise a
 newline is added.  In either case, checking is stopped.  This supports
 exactly the old newline insertion behavior."
 ;; newline only after semicolon, but only if that semicolon is not
 ;; inside a parenthesis list (e.g. a for loop statement)
-(if (/= last-command-char ?\;)
+(if (not (eq last-command-char ?\;))
 nil				; continue checking
 (if (condition-case nil
 	    (save-excursion
 	      (up-list -1)
-	      (/= (following-char) ?\())
+	      (not (eq (char-after) ?\()))
 	  (error t))
 	t
 'stop)))

Mercurial > hg > xemacs-beta

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