1. xemacs
  2. c-support

Commits

andreasj  committed dc46bba

Apply Patch by Jeff Miller from
<14404.42804.804304.478170@max3p112.smart.net>
with subject "synch hideif.el with Emacs 20.4".

  • Participants
  • Parent commits 70f8a85
  • Branches default
  • Tags sumo-1999-12-09, sumo-1999-12-11

Comments (0)

Files changed (2)

File ChangeLog

View file
+1999-09-09  Jeff Miller  <jmiller@smart.net>
+
+	* hideif.el: sync with Emacs 20.4.
+
 1999-03-02  SL Baur  <steve@xemacs.org>
 
 	* hideif.el (hide-ifdef-mode-map): Autoload.

File hideif.el

View file
 
 ;; This file is part of XEmacs.
 
-;; XEmacs is free software; you can redistribute it and/or modify it
-;; under the terms of the GNU General Public License as published by
+;; XEmacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
 ;; the Free Software Foundation; either version 2, or (at your option)
 ;; any later version.
 
-;; XEmacs is distributed in the hope that it will be useful, but
-;; WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-;; General Public License for more details.
+;; XEmacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
 
 ;; You should have received a copy of the GNU General Public License
-;; along with XEmacs; see the file COPYING.  If not, write to the Free
-;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-;; 02111-1307, USA.
+;; along with XEmacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, 
+;; Boston, MA 02111-1307, USA.
 
-;;; Synched up with: FSF 19.34.
+;;; Synched up with: FSF 20.4.
 
 ;;; Commentary:
 
 ;;	 (hide-ifdef-use-define-alist 'list2) ; use list2 by default
 ;;	 ))
 ;;
-;; You can call hide-ifdef-use-define-alist (C-c u) at any time to specify
+;; You can call hide-ifdef-use-define-alist (C-c @ u) at any time to specify
 ;; another list to use.
 ;;
 ;; To cause ifdefs to be hidden as soon as hide-ifdef-mode is called,
 
 (require 'cc-mode)
 
+(defgroup hide-ifdef nil
+  "Hide selected code within `ifdef'."
+  :group 'c)
+
 (defvar hide-ifdef-mode-submap nil
   "Keymap used with Hide-Ifdef mode.")
 
   (define-key hide-ifdef-mode-submap "\C-s" 'show-ifdef-block)
 
   (define-key hide-ifdef-mode-submap "\C-q" 'hide-ifdef-toggle-read-only)
-  (let ((where (where-is-internal 'toggle-read-only nil t)))
+;;(let ((where (where-is-internal 'toggle-read-only '(keymap) t)))
+;; XEmacs change 
+  (let ((where (where-is-internal 'toggle-read-only nil  t)))
     (if where
 	(define-key hide-ifdef-mode-submap
 	  where
 (modify-syntax-entry ?& "." hide-ifdef-syntax-table)
 (modify-syntax-entry ?\| "." hide-ifdef-syntax-table)
 
+(defvar hide-ifdef-env nil
+  "An alist of defined symbols and their values.")
+
+(defvar hif-outside-read-only nil
+  "Internal variable.  Saves the value of `buffer-read-only' while hiding.")
+
 ;;;###autoload
 (defun hide-ifdef-mode (arg)
   "Toggle Hide-Ifdef mode.  This is a minor mode, albeit a large one.
 	(if (null arg)
 	    (not hide-ifdef-mode)
 	  (> (prefix-numeric-value arg) 0)))
-  
+
   ;; XEmacs change
   (redraw-modeline)
 
   (if hide-ifdef-mode
       (progn
-	; fix c-mode syntax table so we can recognize whole symbols.
-	;; XEmacs:  Maybe we don't need this any more with cc-mode? -sb
-	;; (modify-syntax-entry ?_ "w")
-	;; (modify-syntax-entry ?& ".")
-	;; (modify-syntax-entry ?\| ".")
-
 	; inherit global values
 	(make-local-variable 'hide-ifdef-env)
 	(setq hide-ifdef-env (default-value 'hide-ifdef-env))
 (defvar hif-undefined-symbol nil
   "...is by default considered to be false.")
 
-(defvar hide-ifdef-env nil
-  "An alist of defined symbols and their values.")
-
 
 (defun hif-set-var (var value)
   "Prepend (var value) pair to hide-ifdef-env."
 (defconst hif-ifx-else-endif-regexp
   (concat hif-ifx-regexp "\\|" hif-else-regexp "\\|" hif-endif-regexp))
 
+; Used to store the current token and the whole token list during parsing.
+; Only bound dynamically.
+(defvar hif-token)
+(defvar hif-token-list)
 
 (defun hif-infix-to-prefix (token-list)
   "Convert list of tokens in infix into prefix list"
 
 ; pattern to match initial identifier, !, &&, ||, (, or ).
 ; Added ==, + and -: garyo@avs.com 8/9/94
-(defconst hif-token-regexp "^\\(!\\|&&\\|||\\|[!=]=\\|[()+-]\\|\\w+\\)")
+(defconst hif-token-regexp "^\\(&&\\|||\\|[!=]=\\|!\\|[()+-]\\|[<>]=?\\|\\w+\\)")
 (defconst hif-end-of-comment "\\*/")
 
 
 			((string-equal token "defined") 'hif-defined)
 			((string-equal token "(") 'lparen)
 			((string-equal token ")") 'rparen)
+			((string-equal token ">") 'hif-greater)
+			((string-equal token "<") 'hif-less)
+			((string-equal token ">=") 'hif-greater-equal)
+			((string-equal token "<=") 'hif-less-equal)
 			((string-equal token "+") 'hif-plus)
 			((string-equal token "-") 'hif-minus)
 			(t (intern token)))
 ;;; This parser is limited to the operators &&, ||, !, and "defined".
 ;;; Added ==, !=, +, and -.  Gary Oberbrunner, garyo@avs.com, 8/9/94
 
-(defun hif-parse-if-exp (token-list)
+(defun hif-parse-if-exp (hif-token-list)
   "Parse the TOKEN-LIST.  Return translated list in prefix form."
   (hif-nexttoken)
   (prog1
       (hif-expr)
-    (if token ; is there still a token?
-	(error "Error: unexpected token: %s" token))))
+    (if hif-token ; is there still a token?
+	(error "Error: unexpected token: %s" hif-token))))
 
 (defun hif-nexttoken ()
-  "Pop the next token from token-list into the let variable \"token\"."
-  (setq token (car token-list))
-  (setq token-list (cdr token-list))
-  token)
+  "Pop the next token from token-list into the let variable \"hif-token\"."
+  (setq hif-token (car hif-token-list))
+  (setq hif-token-list (cdr hif-token-list))
+  hif-token)
 
 (defun hif-expr ()
   "Parse an expression as found in #if.
        expr : term | expr '||' term."
   (let ((result (hif-term)))
-    (while (eq  token 'or)
+    (while (eq  hif-token 'or)
       (hif-nexttoken)
       (setq result (list 'or result (hif-term))))
   result))
 (defun hif-term ()
   "Parse a term : eq-expr | term '&&' eq-expr."
   (let ((result (hif-eq-expr)))
-    (while (eq token 'and)
+    (while (eq hif-token 'and)
       (hif-nexttoken)
       (setq result (list 'and result (hif-eq-expr))))
     result))
 
 (defun hif-eq-expr ()
-  "Parse an eq-expr : math | eq-expr '=='|'!=' math."
+  "Parse an eq-expr : math | eq-expr `=='|`!='|`<'|`>'|`>='|`<=' math."
   (let ((result (hif-math))
 	(eq-token nil))
-    (while (or (eq token 'equal) (eq token 'hif-notequal))
-      (setq eq-token token)
+    (while (memq hif-token '(equal hif-notequal hif-greater hif-less
+				   hif-greater-equal hif-less-equal))
+      (setq eq-token hif-token)
       (hif-nexttoken)
       (setq result (list eq-token result (hif-math))))
     result))
        math : factor | math '+|-' factor."
   (let ((result (hif-factor))
 	(math-op nil))
-    (while (or (eq  token 'hif-plus) (eq token 'hif-minus))
-      (setq math-op token)
+    (while (or (eq  hif-token 'hif-plus) (eq hif-token 'hif-minus))
+      (setq math-op hif-token)
       (hif-nexttoken)
       (setq result (list math-op result (hif-factor))))
   result))
 (defun hif-factor ()
   "Parse a factor: '!' factor | '(' expr ')' | 'defined(' id ')' | id."
   (cond
-    ((eq token 'not)
+    ((eq hif-token 'not)
      (hif-nexttoken)
      (list 'not (hif-factor)))
 
-    ((eq token 'lparen)
+    ((eq hif-token 'lparen)
      (hif-nexttoken)
      (let ((result (hif-expr)))
-       (if (not (eq token 'rparen))
-	   (error "Bad token in parenthesized expression: %s" token)
+       (if (not (eq hif-token 'rparen))
+	   (error "Bad token in parenthesized expression: %s" hif-token)
 	 (hif-nexttoken)
 	 result)))
 
-    ((eq token 'hif-defined)
+    ((eq hif-token 'hif-defined)
      (hif-nexttoken)
-     (if (not (eq token 'lparen))
+     (if (not (eq hif-token 'lparen))
 	 (error "Error: expected \"(\" after \"defined\""))
      (hif-nexttoken)
-     (let ((ident token))
-       (if (memq token '(or and not hif-defined lparen rparen))
-	   (error "Error: unexpected token: %s" token))
+     (let ((ident hif-token))
+       (if (memq hif-token '(or and not hif-defined lparen rparen))
+	   (error "Error: unexpected token: %s" hif-token))
        (hif-nexttoken)
-       (if (not (eq token 'rparen))
+       (if (not (eq hif-token 'rparen))
 	   (error "Error: expected \")\" after identifier"))
        (hif-nexttoken)
        (` (hif-defined (quote (, ident))))
        ))
 
     (t ; identifier
-      (let ((ident token))
+      (let ((ident hif-token))
 	(if (memq ident '(or and))
 	    (error "Error: missing identifier"))
 	(hif-nexttoken)
 (defun hif-notequal (a b)
   "Like (not (equal A B)) but as one symbol."
   (not (equal a b)))
-
+(defun hif-greater (a b)
+  "Simple comparison."
+  (> (hif-mathify a) (hif-mathify b)))
+(defun hif-less (a b)
+  "Simple comparison."
+  (< (hif-mathify a) (hif-mathify b)))
+(defun hif-greater-equal (a b)
+  "Simple comparison."
+  (>= (hif-mathify a) (hif-mathify b)))
+(defun hif-less-equal (a b)
+  "Simple comparison."
+  (<= (hif-mathify a) (hif-mathify b)))
 ;;;----------- end of parser -----------------------
 
 
     (let ((start (point)))
       (hif-find-previous-relevant)
       (if (= start (point))
-	  (error "No previous #ifdefs, #elses, or #endifs")))))
+	  (error "No previous #ifdefs, #elses, or #endifs")
+	))))
 
 
 ;===%%SF%% parsing (End)  ===
 ;===%%SF%% exports (Start)  ===
 
 ;;;###autoload
-(defvar hide-ifdef-initially nil
-  "*Non-nil means call `hide-ifdefs' when Hide-Ifdef mode is first activated.")
+(defcustom hide-ifdef-initially nil
+  "*Non-nil means call `hide-ifdefs' when Hide-Ifdef mode is first activated."
+  :type 'boolean
+  :group 'hide-ifdef)
 
 ;;;###autoload
-(defvar hide-ifdef-read-only nil
-  "*Set to non-nil if you want buffer to be read-only while hiding text.")
-
-(defvar hif-outside-read-only nil
-  "Internal variable.  Saves the value of `buffer-read-only' while hiding.")
+(defcustom hide-ifdef-read-only nil
+  "*Set to non-nil if you want buffer to be read-only while hiding text."
+  :type 'boolean
+  :group 'hide-ifdef)
 
 ;;;###autoload
-(defvar hide-ifdef-lines nil
-  "*Non-nil means hide the #ifX, #else, and #endif lines.")
+(defcustom hide-ifdef-lines nil
+  "*Non-nil means hide the #ifX, #else, and #endif lines."
+  :type 'boolean
+  :group 'hide-ifdef)
 
 (defun hide-ifdef-toggle-read-only ()
   "Toggle hide-ifdef-read-only."
 
 (defun hif-find-ifdef-block ()
   "Utility for hide and show `ifdef-block'.
-Set top and bottom of ifdef block."
+Return as (TOP . BOTTOM) the extent of ifdef block."
   (let (max-bottom)
-  (save-excursion
-    (beginning-of-line)
-    (if (not (or (hif-looking-at-else) (hif-looking-at-ifX)))
-	(up-ifdef))
-    (setq top (point))
-    (hif-ifdef-to-endif)
-    (setq max-bottom (1- (point))))
-  (save-excursion
-    (beginning-of-line)
-    (if (not (hif-looking-at-endif))
-	(hif-find-next-relevant))
-    (while (hif-looking-at-ifX)
-      (hif-ifdef-to-endif)
-      (hif-find-next-relevant))
-    (setq bottom (min max-bottom (1- (point)))))))
+    (cons (save-excursion
+	    (beginning-of-line)
+	    (if (not (or (hif-looking-at-else) (hif-looking-at-ifX)))
+		(up-ifdef))
+	    (prog1 (point)
+	      (hif-ifdef-to-endif)
+	      (setq max-bottom (1- (point)))))
+	  (save-excursion
+	    (beginning-of-line)
+	    (if (not (hif-looking-at-endif))
+		(hif-find-next-relevant))
+	    (while (hif-looking-at-ifX)
+	      (hif-ifdef-to-endif)
+	      (hif-find-next-relevant))
+	    (min max-bottom (1- (point)))))))
 
 
 (defun hide-ifdef-block ()
   (if (not hide-ifdef-mode)
       (hide-ifdef-mode 1))
   (setq selective-display t)
-  (let (top bottom (inhibit-read-only t))
-    (hif-find-ifdef-block) ; set top and bottom - dynamic scoping
-    (hide-ifdef-region top bottom)
+  (let ((top-bottom  (hif-find-ifdef-block))
+	(inhibit-read-only t))
+    (hide-ifdef-region (car top-bottom) (cdr top-bottom))
     (if hide-ifdef-lines
 	(progn
-	  (hif-hide-line top)
-	  (hif-hide-line (1+ bottom))))
+	  (hif-hide-line (car top-bottom))
+	  (hif-hide-line (1+ (cdr top-bottom)))))
     (setq hide-ifdef-hiding t))
   (setq buffer-read-only (or hide-ifdef-read-only hif-outside-read-only)))
 
 	  (beginning-of-line)
 	  (hif-show-ifdef-region (1- (point)) (progn (end-of-line) (point))))
 
-      (let (top bottom)
-	(hif-find-ifdef-block)
-	(hif-show-ifdef-region (1- top) bottom)))))
+      (let ((top-bottom (hif-find-ifdef-block)))
+      (hif-show-ifdef-region (1- (car top-bottom)) (cdr top-bottom))))))
 
 
 ;;;  definition alist support