]> code.delx.au - gnu-emacs/blobdiff - lisp/progmodes/hideif.el
Merge multi-tty branch
[gnu-emacs] / lisp / progmodes / hideif.el
index 4cd538efcf8d346461f8c9187b10ecfc0d4e8bf5..bb791b18c1b7410c19654efb266a2d82f3a5415a 100644 (file)
@@ -1,16 +1,17 @@
-;;; hide-ifdef-mode.el --- hides selected code within ifdef.
+;;; hideif.el --- hides selected code within ifdef
 
 
-;;; Copyright (C) 1988, 1994 Free Software Foundation, Inc.
+;; Copyright (C) 1988, 1994, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+;; Free Software Foundation, Inc.
 
 
-;; Author: Dan LaLiberte <liberte@a.cs.uiuc.edu>
+;; Author: Daniel LaLiberte <liberte@holonexus.org>
 ;; Maintainer: FSF
 ;; Maintainer: FSF
-;; Keywords: c
+;; Keywords: c, outlines
 
 ;; This file is part of GNU Emacs.
 
 ;; GNU Emacs is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 
 ;; This file is part of GNU Emacs.
 
 ;; GNU Emacs 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)
+;; the Free Software Foundation; either version 3, or (at your option)
 ;; any later version.
 
 ;; GNU Emacs is distributed in the hope that it will be useful,
 ;; any later version.
 
 ;; GNU Emacs is distributed in the hope that it will be useful,
 ;; GNU General Public License for more details.
 
 ;; You should have received a copy of the GNU General Public License
 ;; GNU General Public License for more details.
 
 ;; 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
 
 ;;; Commentary:
 
 
 ;;; Commentary:
 
-;;; To initialize, toggle the hide-ifdef minor mode with
-;;;
-;;; M-x hide-ifdef-mode
-;;;
-;;; This will set up key bindings and call hide-ifdef-mode-hook if it
-;;; has a value.  To explicitly hide ifdefs using a buffer-local
-;;; define list (default empty), type
-;;;
-;;; M-x hide-ifdefs  or C-c h
-;;;
-;;; Hide-ifdef suppresses the display of code that the preprocessor wouldn't
-;;; pass through.  The support of constant expressions in #if lines is 
-;;; limited to identifiers, parens, and the operators: &&, ||, !, and
-;;; "defined".  Please extend this.
-;;;
-;;; The hidden code is marked by ellipses (...).  Be
-;;; cautious when editing near ellipses, since the hidden text is
-;;; still in the buffer, and you can move the point into it and modify
-;;; text unawares.  If you don't want to see the ellipses, set 
-;;; selective-display-ellipses to nil.  But this can be dangerous.
-;;; You can make your buffer read-only while hide-ifdef-hiding by setting
-;;; hide-ifdef-read-only to a non-nil value.  You can toggle this 
-;;; variable with hide-ifdef-toggle-read-only (C-c C-q).
-;;;
-;;; You can undo the effect of hide-ifdefs by typing
-;;;
-;;; M-x show-ifdefs  or C-c s
-;;;
-;;; Use M-x hide-ifdef-define (C-c d) to define a symbol.
-;;; Use M-x hide-ifdef-undef (C-c u) to undefine a symbol.
-;;;
-;;; If you define or undefine a symbol while hide-ifdef-mode is in effect,
-;;; the display will be updated.  Only the define list for the current
-;;; buffer will be affected.  You can save changes to the local define
-;;; list with hide-ifdef-set-define-alist.  This adds entries 
-;;; to hide-ifdef-define-alist.
-;;;
-;;; If you have defined a hide-ifdef-mode-hook, you can set
-;;; up a list of symbols that may be used by hide-ifdefs as in the
-;;; following example:
-;;;
-;;; (setq hide-ifdef-mode-hook
-;;;      '(lambda ()
-;;;     (if (not hide-ifdef-define-alist)
-;;;         (setq hide-ifdef-define-alist
-;;;              '((list1 ONE TWO)
-;;;                (list2 TWO THREE)
-;;;                )))
-;;;     (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
-;;; another list to use.
-;;;
-;;; To cause ifdefs to be hidden as soon as hide-ifdef-mode is called,
-;;; set hide-ifdef-initially to non-nil.
-;;;
-;;; If you set hide-ifdef-lines to t, hide-ifdefs hides all the #ifdef lines.
-;;; In the absence of highlighting, that might be a bad idea.  If you set
-;;; hide-ifdef-lines to nil (the default), the surrounding preprocessor
-;;; lines will be displayed.  That can be confusing in its own
-;;; right.  Other variations on display are possible, but not much
-;;; better.
-;;;
-;;; You can explicitly hide or show individual ifdef blocks irrespective
-;;; of the define list by using hide-ifdef-block and show-ifdef-block.
-;;;
-;;; You can move the point between ifdefs with forward-ifdef, backward-ifdef,
-;;; up-ifdef, down-ifdef, next-ifdef, and previous-ifdef.
-;;;
-;;; If you have minor-mode-alist in your mode line (the default) two labels
-;;; may appear.  "Ifdef" will appear when hide-ifdef-mode is active.  "Hiding"
-;;; will appear when text may be hidden ("hide-ifdef-hiding" is non-nil).
-;;;
-;;; Written by Brian Marick, at Gould, Computer Systems Division, Urbana IL.
-;;; Extensively modified by Daniel LaLiberte (while at Gould).
-;;;
-;;; You may freely modify and distribute this, but keep a record
-;;; of modifications and send comments to:
-;;;     liberte@a.cs.uiuc.edu  or  ihnp4!uiucdcs!liberte
-;;; I will continue to upgrade hide-ifdef-mode
-;;; with your contributions.
-
-;;; Change Log:
-;;;
-;;; Revision 1.7  88/02/16  03:12:58  liberte
-;;; Fixed comments and doc strings.
-;;; Added optional prefix arg for ifdef motion commands.
-;;; 
-;;; Revision 1.6  88/02/05  00:36:18  liberte
-;;; Bug fixes.
-;;; 1. A multi-line comment that starts on an #ifdef line
-;;;    now ends on that line.
-;;; 2. Fix bad function name: hide-hif-ifdef-toggle-read-only
-;;; 3. Make ifdef-block hiding work outside of ifdefs.
-;;; 
-;;; Revision 1.5  88/01/31  23:19:31  liberte
-;;; Major clean up.
-;;;   Prefix internal names with "hif-".
-;;; 
-;;; Revision 1.4  88/01/30  14:09:38  liberte
-;;; Add hide-ifdef-hiding and hide-ifdef-mode to minor-mode-alist.
-;;; 
-;;; Revision 1.3  88/01/29  00:38:19  liberte
-;;; Fix three bugs.
-;;; 1. Function "defined" is just like lookup.
-;;; 2. Skip to newline or cr in case text is hidden.
-;;; 3. Use car of token list if just one symbol.
-;;;
-;;; Revision 1.2  88/01/28  23:32:46  liberte
-;;; Use hide-ifdef-mode-prefix-key.
-;;; Copy current-local-map so other buffers do not get
-;;; hide-ifdef-mode bindings.
-;;;
+;; To initialize, toggle the hide-ifdef minor mode with
+;;
+;; M-x hide-ifdef-mode
+;;
+;; This will set up key bindings and call hide-ifdef-mode-hook if it
+;; has a value.  To explicitly hide ifdefs using a buffer-local
+;; define list (default empty), type
+;;
+;; M-x hide-ifdefs  or C-c @ h
+;;
+;; Hide-ifdef suppresses the display of code that the preprocessor wouldn't
+;; pass through.  The support of constant expressions in #if lines is
+;; limited to identifiers, parens, and the operators: &&, ||, !, and
+;; "defined".  Please extend this.
+;;
+;; The hidden code is marked by ellipses (...).  Be
+;; cautious when editing near ellipses, since the hidden text is
+;; still in the buffer, and you can move the point into it and modify
+;; text unawares.
+;; You can make your buffer read-only while hide-ifdef-hiding by setting
+;; hide-ifdef-read-only to a non-nil value.  You can toggle this
+;; variable with hide-ifdef-toggle-read-only (C-c @ C-q).
+;;
+;; You can undo the effect of hide-ifdefs by typing
+;;
+;; M-x show-ifdefs  or C-c @ s
+;;
+;; Use M-x hide-ifdef-define (C-c @ d) to define a symbol.
+;; Use M-x hide-ifdef-undef (C-c @ u) to undefine a symbol.
+;;
+;; If you define or undefine a symbol while hide-ifdef-mode is in effect,
+;; the display will be updated.  Only the define list for the current
+;; buffer will be affected.  You can save changes to the local define
+;; list with hide-ifdef-set-define-alist.  This adds entries
+;; to hide-ifdef-define-alist.
+;;
+;; If you have defined a hide-ifdef-mode-hook, you can set
+;; up a list of symbols that may be used by hide-ifdefs as in the
+;; following example:
+;;
+;; (add-hook 'hide-ifdef-mode-hook
+;;      (lambda ()
+;;      (unless hide-ifdef-define-alist
+;;        (setq hide-ifdef-define-alist
+;;             '((list1 ONE TWO)
+;;               (list2 TWO THREE))))
+;;      (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
+;; another list to use.
+;;
+;; To cause ifdefs to be hidden as soon as hide-ifdef-mode is called,
+;; set hide-ifdef-initially to non-nil.
+;;
+;; If you set hide-ifdef-lines to t, hide-ifdefs hides all the #ifdef lines.
+;; In the absence of highlighting, that might be a bad idea.  If you set
+;; hide-ifdef-lines to nil (the default), the surrounding preprocessor
+;; lines will be displayed.  That can be confusing in its own
+;; right.  Other variations on display are possible, but not much
+;; better.
+;;
+;; You can explicitly hide or show individual ifdef blocks irrespective
+;; of the define list by using hide-ifdef-block and show-ifdef-block.
+;;
+;; You can move the point between ifdefs with forward-ifdef, backward-ifdef,
+;; up-ifdef, down-ifdef, next-ifdef, and previous-ifdef.
+;;
+;; If you have minor-mode-alist in your mode line (the default) two labels
+;; may appear.  "Ifdef" will appear when hide-ifdef-mode is active.  "Hiding"
+;; will appear when text may be hidden ("hide-ifdef-hiding" is non-nil).
+;;
+;; Written by Brian Marick, at Gould, Computer Systems Division, Urbana IL.
+;; Extensively modified by Daniel LaLiberte (while at Gould).
+;;
+;; You may freely modify and distribute this, but keep a record
+;; of modifications and send comments to:
+;;      liberte@a.cs.uiuc.edu  or  ihnp4!uiucdcs!liberte
+;; I will continue to upgrade hide-ifdef-mode
+;; with your contributions.
 
 ;;; Code:
 
 
 ;;; Code:
 
-(defvar hide-ifdef-mode-submap nil
-  "Keymap used with Hide-Ifdef mode.")
+(require 'cc-mode)
+
+(defgroup hide-ifdef nil
+  "Hide selected code within `ifdef'."
+  :group 'c)
+
+(defvar hide-ifdef-mode-submap
+  ;; Set up the submap that goes after the prefix key.
+  (let ((map (make-sparse-keymap)))
+    (define-key map "d" 'hide-ifdef-define)
+    (define-key map "u" 'hide-ifdef-undef)
+    (define-key map "D" 'hide-ifdef-set-define-alist)
+    (define-key map "U" 'hide-ifdef-use-define-alist)
+
+    (define-key map "h" 'hide-ifdefs)
+    (define-key map "s" 'show-ifdefs)
+    (define-key map "\C-d" 'hide-ifdef-block)
+    (define-key map "\C-s" 'show-ifdef-block)
 
 
-(defvar hide-ifdef-mode-map nil
-  "Keymap used with Hide-Ifdef mode.")
+    (define-key map "\C-q" 'hide-ifdef-toggle-read-only)
+    (substitute-key-definition
+     'toggle-read-only 'hide-ifdef-toggle-outside-read-only map)
+    map)
+  "Keymap used by `hide-ifdef-mode' under `hide-ifdef-mode-prefix-key'.")
 
 
-(defconst hide-ifdef-mode-prefix-key "\C-c"
+(defconst hide-ifdef-mode-prefix-key "\C-c@"
   "Prefix key for all Hide-Ifdef mode commands.")
 
   "Prefix key for all Hide-Ifdef mode commands.")
 
-;; Set up the submap that goes after the prefix key.
-(if hide-ifdef-mode-submap
-    ()                         ; dont redefine it.
-  (setq hide-ifdef-mode-submap (make-sparse-keymap))
-  (define-key hide-ifdef-mode-submap "\ed" 'hide-ifdef-define)
-  (define-key hide-ifdef-mode-submap "\eu" 'hide-ifdef-undef)
-  (define-key hide-ifdef-mode-submap "\eD" 'hide-ifdef-set-define-alist)
-  (define-key hide-ifdef-mode-submap "\eU" 'hide-ifdef-use-define-alist)
-
-  (define-key hide-ifdef-mode-submap "\eh" 'hide-ifdefs)
-  (define-key hide-ifdef-mode-submap "\es" 'show-ifdefs)
-  (define-key hide-ifdef-mode-submap "\C-d" 'hide-ifdef-block)
-  (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 '(keymap) t)))
-    (if where
-       (define-key hide-ifdef-mode-submap
-         where
-         'hide-ifdef-toggle-outside-read-only)))
-  )
-
-;; Set up the mode's main map, which leads via the prefix key to the submap.
-(if hide-ifdef-mode-map
-    ()
-  (setq hide-ifdef-mode-map (make-sparse-keymap))
-  (define-key hide-ifdef-mode-map hide-ifdef-mode-prefix-key
-    hide-ifdef-mode-submap))
-
-(defun hif-update-mode-line ()
-  "Update mode-line by setting buffer-modified to itself."
-  (set-buffer-modified-p (buffer-modified-p)))
-
-(defvar hide-ifdef-mode nil
-  "Non-nil when hide-ifdef-mode is activated.")
+(defvar hide-ifdef-mode-map
+  ;; Set up the mode's main map, which leads via the prefix key to the submap.
+  (let ((map (make-sparse-keymap)))
+    (define-key map hide-ifdef-mode-prefix-key hide-ifdef-mode-submap)
+    map)
+  "Keymap used with `hide-ifdef-mode'.")
 
 (defvar hide-ifdef-hiding nil
   "Non-nil when text may be hidden.")
 
 
 (defvar hide-ifdef-hiding nil
   "Non-nil when text may be hidden.")
 
-;; Arrange to use the mode's map when the mode is enabled.
-(or (assq 'hide-ifdef-mode minor-mode-map-alist)
-    (setq minor-mode-map-alist
-          (cons (cons 'hide-ifdef-mode hide-ifdef-mode-map)
-                minor-mode-map-alist)))
-
 (or (assq 'hide-ifdef-hiding minor-mode-alist)
     (setq minor-mode-alist
           (cons '(hide-ifdef-hiding " Hiding")
                 minor-mode-alist)))
 
 (or (assq 'hide-ifdef-hiding minor-mode-alist)
     (setq minor-mode-alist
           (cons '(hide-ifdef-hiding " Hiding")
                 minor-mode-alist)))
 
-(or (assq 'hide-ifdef-mode minor-mode-alist)
-    (setq minor-mode-alist
-          (cons '(hide-ifdef-mode " Ifdef")
-                minor-mode-alist)))
-
 ;; fix c-mode syntax table so we can recognize whole symbols.
 (defvar hide-ifdef-syntax-table
 ;; fix c-mode syntax table so we can recognize whole symbols.
 (defvar hide-ifdef-syntax-table
-  (copy-syntax-table c-mode-syntax-table)
+  (let ((st (copy-syntax-table c-mode-syntax-table)))
+    (modify-syntax-entry ?_ "w" st)
+    (modify-syntax-entry ?& "." st)
+    (modify-syntax-entry ?\| "." st)
+    st)
   "Syntax table used for tokenizing #if expressions.")
 
   "Syntax table used for tokenizing #if expressions.")
 
-(modify-syntax-entry ?_ "w" hide-ifdef-syntax-table)
-(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
 
 ;;;###autoload
-(defun hide-ifdef-mode (arg)
+(define-minor-mode hide-ifdef-mode
   "Toggle Hide-Ifdef mode.  This is a minor mode, albeit a large one.
   "Toggle Hide-Ifdef mode.  This is a minor mode, albeit a large one.
-With ARG, turn Hide-Ifdef mode on iff arg is positive.
+With ARG, turn Hide-Ifdef mode on if arg is positive, off otherwise.
 In Hide-Ifdef mode, code within #ifdef constructs that the C preprocessor
 would eliminate may be hidden from view.  Several variables affect
 how the hiding is done:
 
 In Hide-Ifdef mode, code within #ifdef constructs that the C preprocessor
 would eliminate may be hidden from view.  Several variables affect
 how the hiding is done:
 
-hide-ifdef-env
+`hide-ifdef-env'
        An association list of defined and undefined symbols for the
        current buffer.  Initially, the global value of `hide-ifdef-env'
        is used.
 
        An association list of defined and undefined symbols for the
        current buffer.  Initially, the global value of `hide-ifdef-env'
        is used.
 
-hide-ifdef-define-alist
-       An association list of defined symbol lists.  
+`hide-ifdef-define-alist'
+       An association list of defined symbol lists.
         Use `hide-ifdef-set-define-alist' to save the current `hide-ifdef-env'
         and `hide-ifdef-use-define-alist' to set the current `hide-ifdef-env'
         from one of the lists in `hide-ifdef-define-alist'.
 
         Use `hide-ifdef-set-define-alist' to save the current `hide-ifdef-env'
         and `hide-ifdef-use-define-alist' to set the current `hide-ifdef-env'
         from one of the lists in `hide-ifdef-define-alist'.
 
-hide-ifdef-lines
+`hide-ifdef-lines'
        Set to non-nil to not show #if, #ifdef, #ifndef, #else, and
        #endif lines when hiding.
 
        Set to non-nil to not show #if, #ifdef, #ifndef, #else, and
        #endif lines when hiding.
 
-hide-ifdef-initially
+`hide-ifdef-initially'
        Indicates whether `hide-ifdefs' should be called when Hide-Ifdef mode
        is activated.
 
        Indicates whether `hide-ifdefs' should be called when Hide-Ifdef mode
        is activated.
 
-hide-ifdef-read-only
+`hide-ifdef-read-only'
        Set to non-nil if you want to make buffers read only while hiding.
        After `show-ifdefs', read-only status is restored to previous value.
 
 \\{hide-ifdef-mode-map}"
        Set to non-nil if you want to make buffers read only while hiding.
        After `show-ifdefs', read-only status is restored to previous value.
 
 \\{hide-ifdef-mode-map}"
-
-  (interactive "P")
-  (make-local-variable 'hide-ifdef-mode)
-  (setq hide-ifdef-mode
-       (if (null arg)
-           (not hide-ifdef-mode)
-         (> (prefix-numeric-value arg) 0)))
-  
-  (force-mode-line-update)
-
+  :group 'hide-ifdef :lighter " Ifdef"
   (if hide-ifdef-mode
       (progn
   (if hide-ifdef-mode
       (progn
-       ; inherit global values
-       (make-local-variable 'hide-ifdef-env)
-       (setq hide-ifdef-env (default-value 'hide-ifdef-env))
-
-       (make-local-variable 'hide-ifdef-hiding)
-       (setq hide-ifdef-hiding (default-value 'hide-ifdef-hiding))
-
-       (make-local-variable 'hif-outside-read-only)
-       (setq hif-outside-read-only buffer-read-only)
-
-       (run-hooks 'hide-ifdef-mode-hook)
+       ;; inherit global values
+       (set (make-local-variable 'hide-ifdef-env)
+            (default-value 'hide-ifdef-env))
+       (set (make-local-variable 'hide-ifdef-hiding)
+            (default-value 'hide-ifdef-hiding))
+       (set (make-local-variable 'hif-outside-read-only) buffer-read-only)
+       (set (make-local-variable 'line-move-ignore-invisible) t)
+       (add-hook 'change-major-mode-hook
+                 (lambda () (hide-ifdef-mode -1)) nil t)
+
+       (add-to-invisibility-spec '(hide-ifdef . t))
 
        (if hide-ifdef-initially
            (hide-ifdefs)
 
        (if hide-ifdef-initially
            (hide-ifdefs)
-         (show-ifdefs))
-       (message "Enter hide-ifdef-mode.")
-       )
-     ; else end hide-ifdef-mode
+         (show-ifdefs)))
+    ;; else end hide-ifdef-mode
+    (kill-local-variable 'line-move-ignore-invisible)
+    (remove-from-invisibility-spec '(hide-ifdef . t))
     (if hide-ifdef-hiding
     (if hide-ifdef-hiding
-       (show-ifdefs))
-    (message "Exit hide-ifdef-mode.")
-    ))
-  
-
-;; from outline.el with docstring fixed.
-(defun hif-outline-flag-region (from to flag)
-  "Hides or shows lines from FROM to TO, according to FLAG.  If FLAG
-is \\n (newline character) then text is shown, while if FLAG is \\^M
-\(control-M) the text is hidden."
-  (let ((modp (buffer-modified-p)))
-    (unwind-protect (progn
-                     (subst-char-in-region from to
-                             (if (= flag ?\n) ?\^M ?\n)
-                             flag t) )
-      (set-buffer-modified-p modp))
-    ))
+       (show-ifdefs))))
+
 
 (defun hif-show-all ()
   "Show all of the text in the current buffer."
   (interactive)
 
 (defun hif-show-all ()
   "Show all of the text in the current buffer."
   (interactive)
-  (hif-outline-flag-region (point-min) (point-max) ?\n))
+  (hif-show-ifdef-region (point-min) (point-max)))
+
+;; By putting this on after-revert-hook, we arrange that it only
+;; does anything when revert-buffer avoids turning off the mode.
+;; (That can happen in VC.)
+(defun hif-after-revert-function ()
+  (and hide-ifdef-mode hide-ifdef-hiding
+       (hide-ifdefs t)))
+(add-hook 'after-revert-hook 'hif-after-revert-function)
+
+(defun hif-end-of-line ()
+  (end-of-line)
+  (while (= (logand 1 (skip-chars-backward "\\\\")) 1)
+    (end-of-line 2)))
+
+(defun hide-ifdef-region-internal (start end)
+  (remove-overlays start end 'invisible 'hide-ifdef)
+  (let ((o (make-overlay start end)))
+    (overlay-put o 'invisible 'hide-ifdef)))
 
 (defun hide-ifdef-region (start end)
   "START is the start of a #if or #else form.  END is the ending part.
 Everything including these lines is made invisible."
 
 (defun hide-ifdef-region (start end)
   "START is the start of a #if or #else form.  END is the ending part.
 Everything including these lines is made invisible."
-  (hif-outline-flag-region start end ?\^M)
-  )
+  (save-excursion
+    (goto-char start) (hif-end-of-line) (setq start (point))
+    (goto-char end) (hif-end-of-line) (setq end (point))
+    (hide-ifdef-region-internal start end)))
 
 (defun hif-show-ifdef-region (start end)
   "Everything between START and END is made visible."
 
 (defun hif-show-ifdef-region (start end)
   "Everything between START and END is made visible."
-  (hif-outline-flag-region start end ?\n)
-  )
+  (remove-overlays start end 'invisible 'hide-ifdef))
 
 
 
 
+;;===%%SF%% evaluation (Start)  ===
 
 
-;===%%SF%% evaluation (Start)  ===
-
+;; It is not useful to set this to anything but `eval'.
+;; In fact, the variable might as well be eliminated.
 (defvar hide-ifdef-evaluator 'eval
 (defvar hide-ifdef-evaluator 'eval
-  "The evaluator is given a canonical form and returns T if text under
+  "The function to use to evaluate a form.
+The evaluator is given a canonical form and returns t if text under
 that form should be displayed.")
 
 (defvar hif-undefined-symbol nil
   "...is by default considered to be false.")
 
 that form should be displayed.")
 
 (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."
 
 (defun hif-set-var (var value)
   "Prepend (var value) pair to hide-ifdef-env."
@@ -332,26 +278,20 @@ that form should be displayed.")
 
 
 (defun hif-lookup (var)
 
 
 (defun hif-lookup (var)
- (message "hif-lookup %s" var)
+  ;; (message "hif-lookup %s" var)
   (let ((val (assoc var hide-ifdef-env)))
     (if val
        (cdr val)
       hif-undefined-symbol)))
 
 (defun hif-defined (var)
   (let ((val (assoc var hide-ifdef-env)))
     (if val
        (cdr val)
       hif-undefined-symbol)))
 
 (defun hif-defined (var)
-  (hif-lookup var)
-  ; when #if expressions are fully supported, defined result should be 1
-  ;  (if (assoc var  hide-ifdef-env)
-  ;      1
-  ;    nil)
-)
-
+   (if (assoc var hide-ifdef-env) 1 0))
 
 
-;===%%SF%% evaluation (End)  ===
+;;===%%SF%% evaluation (End)  ===
 
 
 
 
 
 
-;===%%SF%% parsing (Start)  ===
+;;===%%SF%% parsing (Start)  ===
 ;;;  The code that understands what ifs and ifdef in files look like.
 
 (defconst hif-cpp-prefix "\\(^\\|\r\\)[ \t]*#[ \t]*")
 ;;;  The code that understands what ifs and ifdef in files look like.
 
 (defconst hif-cpp-prefix "\\(^\\|\r\\)[ \t]*#[ \t]*")
@@ -362,192 +302,237 @@ that form should be displayed.")
 (defconst hif-ifx-else-endif-regexp
   (concat hif-ifx-regexp "\\|" hif-else-regexp "\\|" hif-endif-regexp))
 
 (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)
+
+;; pattern to match initial identifier, !, &&, ||, (, or ).
+;; Added ==, + and -: garyo@avs.com 8/9/94
+(defconst hif-token-regexp
+  "\\(&&\\|||\\|[!=]=\\|!\\|[()+?:-]\\|[<>]=?\\|\\w+\\)")
 
 
-(defun hif-infix-to-prefix (token-list)
-  "Convert list of tokens in infix into prefix list"
-;  (message "hif-infix-to-prefix: %s" token-list)
-  (if (= 1 (length token-list))
-      (` (hif-lookup (quote (, (car token-list)))))
-    (hif-parse-if-exp token-list))
-  )
-
-; pattern to match initial identifier, !, &&, ||, (, or ).
-(defconst hif-token-regexp "^\\(!\\|&&\\|||\\|[()]\\|\\w+\\)")
-(defconst hif-end-of-comment "\\*/")
-
-
-(defun hif-tokenize (expr-string)
-  "Separate string into a list of tokens"
-  (let ((token-list nil)
-       (expr-start 0)
-       (expr-length (length expr-string))
-       (current-syntax-table (syntax-table)))
-    (unwind-protect
-       (progn
-         (set-syntax-table hide-ifdef-syntax-table)
-         (while (< expr-start expr-length) 
-;          (message "expr-start = %d" expr-start) (sit-for 1)
-           (cond
-            ((string-match "^[ \t]+" expr-string expr-start)
-             ;; skip whitespace
-             (setq expr-start (match-end 0))
-             ;; stick newline in string so ^ matches on the next string-match
-             (aset expr-string (1- expr-start) ?\n))
-
-            ((string-match "^/\\*" expr-string expr-start)
-             (setq expr-start (match-end 0))
-             (aset expr-string (1- expr-start) ?\n)
-             (or
-              (string-match hif-end-of-comment
-                            expr-string expr-start) ; eat comment
-              (string-match "$" expr-string expr-start)) ; multi-line comment
-             (setq expr-start (match-end 0))
-             (aset expr-string (1- expr-start) ?\n))
-
-            ((string-match "^//" expr-string expr-start)
-             (string-match "$" expr-string expr-start)
-             (setq expr-start (match-end 0)))
-
-            ((string-match hif-token-regexp expr-string expr-start)
-             (let ((token (substring expr-string expr-start (match-end 0))))
-               (setq expr-start (match-end 0))
-               (aset expr-string (1- expr-start) ?\n)
-;              (message "token: %s" token) (sit-for 1)
-               (setq token-list
-                     (cons
-                      (cond
-                       ((string-equal token "||") 'or)
-                       ((string-equal token "&&") 'and)
-                       ((string-equal token "!")  'not)
-                       ((string-equal token "defined") 'hif-defined)
-                       ((string-equal token "(") 'lparen)
-                       ((string-equal token ")") 'rparen)
-                       (t (intern token)))
-                      token-list))))
-
-            (t (error "Bad #if expression: %s" expr-string)))))
-      (set-syntax-table current-syntax-table))
+(defun hif-tokenize (start end)
+  "Separate string between START and END into a list of tokens."
+  (let ((token-list nil))
+    (with-syntax-table hide-ifdef-syntax-table
+      (save-excursion
+       (goto-char start)
+       (while (progn (forward-comment (point-max)) (< (point) end))
+         ;; (message "expr-start = %d" expr-start) (sit-for 1)
+         (cond
+          ((looking-at "\\\\\n")
+           (forward-char 2))
+
+          ((looking-at hif-token-regexp)
+           (let ((token (buffer-substring (point) (match-end 0))))
+             (goto-char (match-end 0))
+             ;; (message "token: %s" token) (sit-for 1)
+             (push (cond
+                    ((string-equal token "||") 'or)
+                    ((string-equal token "&&") 'and)
+                    ((string-equal token "==") 'equal)
+                    ((string-equal token "!=") 'hif-notequal)
+                    ((string-equal token "!")  'not)
+                    ((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)
+                    ((string-equal token "?") 'hif-conditional)
+                    ((string-equal token ":") 'hif-colon)
+                    ((string-match "\\`[0-9]*\\'" token)
+                     (string-to-number token))
+                    (t (intern token)))
+                   token-list)))
+          (t (error "Bad #if expression: %s" (buffer-string)))))))
     (nreverse token-list)))
 
 ;;;-----------------------------------------------------------------
 ;;; Translate C preprocessor #if expressions using recursive descent.
 ;;; This parser is limited to the operators &&, ||, !, and "defined".
     (nreverse token-list)))
 
 ;;;-----------------------------------------------------------------
 ;;; Translate C preprocessor #if expressions using recursive descent.
 ;;; 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)
+(defsubst hif-nexttoken ()
+  "Pop the next token from token-list into the let variable \"hif-token\"."
+  (setq hif-token (pop hif-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)
   "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))))
-
-(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)
+    (if hif-token ; is there still a token?
+       (error "Error: unexpected token: %s" hif-token))))
 
 (defun hif-expr ()
 
 (defun hif-expr ()
-  "Parse and expression of the form
-       expr : term | expr '||' term."
-  (let ((result (hif-term)))
-    (while (eq  token 'or)
+  "Parse an expression as found in #if.
+       expr : or-expr | or-expr '?' expr ':' expr."
+  (let ((result (hif-or-expr))
+       middle)
+    (while (eq hif-token 'hif-conditional)
       (hif-nexttoken)
       (hif-nexttoken)
-      (setq result (list 'or result (hif-term))))
+      (setq middle (hif-expr))
+      (if (eq hif-token 'hif-colon)
+         (progn
+           (hif-nexttoken)
+           (setq result (list 'hif-conditional result middle (hif-expr))))
+       (error "Error: unexpected token: %s" hif-token)))
+    result))
+
+(defun hif-or-expr ()
+  "Parse n or-expr : and-expr | or-expr '||' and-expr."
+  (let ((result (hif-and-expr)))
+    (while (eq hif-token 'or)
+      (hif-nexttoken)
+      (setq result (list 'hif-or result (hif-and-expr))))
   result))
 
   result))
 
-(defun hif-term ()
-  "Parse a term of the form
-       term : factor | term '&&' factor."
-  (let ((result (hif-factor)))
-    (while (eq token 'and)
+(defun hif-and-expr ()
+  "Parse an and-expr : eq-expr | and-expr '&&' eq-expr."
+  (let ((result (hif-eq-expr)))
+    (while (eq hif-token 'and)
+      (hif-nexttoken)
+      (setq result (list 'hif-and result (hif-eq-expr))))
+    result))
+
+(defun hif-eq-expr ()
+  "Parse an eq-expr : math | eq-expr `=='|`!='|`<'|`>'|`>='|`<=' math."
+  (let ((result (hif-math))
+       (eq-token nil))
+    (while (memq hif-token '(equal hif-notequal hif-greater hif-less
+                            hif-greater-equal hif-less-equal))
+      (setq eq-token hif-token)
       (hif-nexttoken)
       (hif-nexttoken)
-      (setq result (list 'and result (hif-factor))))
+      (setq result (list eq-token result (hif-math))))
     result))
 
     result))
 
+(defun hif-math ()
+  "Parse an expression with + or - and simpler things.
+       math : factor | math '+|-' factor."
+  (let ((result (hif-factor))
+       (math-op nil))
+    (while (memq hif-token '(hif-plus hif-minus))
+      (setq math-op hif-token)
+      (hif-nexttoken)
+      (setq result (list math-op result (hif-factor))))
+  result))
+
 (defun hif-factor ()
 (defun hif-factor ()
-  "Parse a factor of the form
-       factor : '!' factor | '(' expr ')' | 'defined(' id ')' | id."
+  "Parse a factor: '!' factor | '(' expr ')' | 'defined(' id ')' | id."
   (cond
   (cond
-    ((eq token 'not)
-     (hif-nexttoken)
-     (list 'not (hif-factor)))
-
-    ((eq token 'lparen)
-     (hif-nexttoken)
-     (let ((result (hif-expr)))
-       (if (not (eq token 'rparen))
-          (error "Bad token in parenthesized expression: %s" token)
-        (hif-nexttoken)
-        result)))
-
-    ((eq token 'hif-defined)
-     (hif-nexttoken)
-     (if (not (eq 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))
-       (hif-nexttoken)
-       (if (not (eq token 'rparen))
-          (error "Error: expected \")\" after identifier"))
-       (hif-nexttoken)
-       (` (hif-defined (quote (, ident))))
-       ))
-
-    (t ; identifier
-      (let ((ident token))
-       (if (memq ident '(or and))
-           (error "Error: missing identifier"))
+   ((eq hif-token 'not)
+    (hif-nexttoken)
+    (list 'hif-not (hif-factor)))
+
+   ((eq hif-token 'lparen)
+    (hif-nexttoken)
+    (let ((result (hif-expr)))
+      (if (not (eq hif-token 'rparen))
+         (error "Bad token in parenthesized expression: %s" hif-token)
+       (hif-nexttoken)
+       result)))
+
+   ((eq hif-token 'hif-defined)
+    (hif-nexttoken)
+    (let ((paren (when (eq hif-token 'lparen) (hif-nexttoken) t))
+         (ident hif-token))
+      (if (memq hif-token '(or and not hif-defined lparen rparen))
+         (error "Error: unexpected token: %s" hif-token))
+      (when paren
        (hif-nexttoken)
        (hif-nexttoken)
-       (` (hif-lookup (quote (, ident))))
-       ))
-    ))
+       (unless (eq hif-token 'rparen)
+         (error "Error: expected \")\" after identifier")))
+      (hif-nexttoken)
+      `(hif-defined (quote ,ident))))
+
+   ((numberp hif-token)
+    (prog1 hif-token (hif-nexttoken)))
 
 
+   (t                                  ; identifier
+    (let ((ident hif-token))
+      (if (memq ident '(or and))
+         (error "Error: missing identifier"))
+      (hif-nexttoken)
+      `(hif-lookup (quote ,ident))))))
+
+(defun hif-mathify (val)
+  "Treat VAL as a number: if it's t or nil, use 1 or 0."
+  (cond ((eq val t) 1)
+       ((null val) 0)
+       (t val)))
+
+(defun hif-conditional (a b c)
+  (if (not (zerop (hif-mathify a))) (hif-mathify b) (hif-mathify c)))
+(defun hif-and (a b)
+  (and (not (zerop (hif-mathify a))) (not (zerop (hif-mathify b)))))
+(defun hif-or (a b)
+  (or (not (zerop (hif-mathify a))) (not (zerop (hif-mathify b)))))
+(defun hif-not (a)
+  (zerop (hif-mathify a)))
+(defun hif-plus (a b)
+  "Like ordinary plus but treat t and nil as 1 and 0."
+  (+ (hif-mathify a) (hif-mathify b)))
+(defun hif-minus (a b)
+  "Like ordinary minus but treat t and nil as 1 and 0."
+  (- (hif-mathify a) (hif-mathify b)))
+(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 -----------------------
 
 
 (defun hif-canonicalize ()
 ;;;----------- end of parser -----------------------
 
 
 (defun hif-canonicalize ()
-  "When at beginning of #ifX, returns a canonical (evaluatable)
-       form for the expression."
+  "When at beginning of #ifX, return a Lisp expression for its condition."
   (save-excursion
     (let ((negate (looking-at hif-ifndef-regexp)))
       (re-search-forward hif-ifx-regexp)
   (save-excursion
     (let ((negate (looking-at hif-ifndef-regexp)))
       (re-search-forward hif-ifx-regexp)
-      (let* ((expr-string
-             (buffer-substring (point)
-                               (progn (skip-chars-forward "^\n\r") (point))))
-            (expr (hif-infix-to-prefix (hif-tokenize expr-string))))
-;      (message "hif-canonicalized: %s" expr)
+      (let* ((tokens (hif-tokenize (point)
+                                  (progn (hif-end-of-line) (point))))
+            (expr (hif-parse-if-exp tokens)))
+       ;; (message "hif-canonicalized: %s" expr)
        (if negate
        (if negate
-           (list 'not expr)
+           (list 'hif-not expr)
          expr)))))
 
 
 (defun hif-find-any-ifX ()
          expr)))))
 
 
 (defun hif-find-any-ifX ()
-  "Position at beginning of next #if, #ifdef, or #ifndef, including one on
-this line."
-;  (message "find ifX at %d" (point))
+  "Move to next #if..., or #ifndef, at point or after."
+  ;; (message "find ifX at %d" (point))
   (prog1
       (re-search-forward hif-ifx-regexp (point-max) t)
     (beginning-of-line)))
 
 
 (defun hif-find-next-relevant ()
   (prog1
       (re-search-forward hif-ifx-regexp (point-max) t)
     (beginning-of-line)))
 
 
 (defun hif-find-next-relevant ()
-  "Position at beginning of next #ifdef, #ifndef, #else, #endif,
-NOT including one on this line."
-;  (message "hif-find-next-relevant at %d" (point))
+  "Move to next #if..., #else, or #endif, after the current line."
+  ;; (message "hif-find-next-relevant at %d" (point))
   (end-of-line)
   (end-of-line)
-  ; avoid infinite recursion by only going to beginning of line if match found
+  ;; avoid infinite recursion by only going to beginning of line if match found
   (if (re-search-forward hif-ifx-else-endif-regexp (point-max) t)
       (beginning-of-line)))
 
 (defun hif-find-previous-relevant ()
   (if (re-search-forward hif-ifx-else-endif-regexp (point-max) t)
       (beginning-of-line)))
 
 (defun hif-find-previous-relevant ()
-  "Position at beginning of previous #ifdef, #ifndef, #else, #endif,
-NOT including one on this line."
-;  (message "hif-find-previous-relevant at %d" (point))
+  "Move to previous #if..., #else, or #endif, before the current line."
+  ;; (message "hif-find-previous-relevant at %d" (point))
   (beginning-of-line)
   (beginning-of-line)
-  ; avoid infinite recursion by only going to beginning of line if match found
+  ;; avoid infinite recursion by only going to beginning of line if match found
   (if (re-search-backward hif-ifx-else-endif-regexp (point-min) t)
      (beginning-of-line)))
 
   (if (re-search-backward hif-ifx-else-endif-regexp (point-min) t)
      (beginning-of-line)))
 
@@ -563,7 +548,7 @@ NOT including one on this line."
 
 (defun hif-ifdef-to-endif ()
   "If positioned at #ifX or #else form, skip to corresponding #endif."
 
 (defun hif-ifdef-to-endif ()
   "If positioned at #ifX or #else form, skip to corresponding #endif."
- (message "hif-ifdef-to-endif at %d" (point)) (sit-for 1)
+  ;; (message "hif-ifdef-to-endif at %d" (point)) (sit-for 1)
   (hif-find-next-relevant)
   (cond ((hif-looking-at-ifX)
         (hif-ifdef-to-endif) ; find endif of nested if
   (hif-find-next-relevant)
   (cond ((hif-looking-at-ifX)
         (hif-ifdef-to-endif) ; find endif of nested if
@@ -578,7 +563,7 @@ NOT including one on this line."
 
 (defun hif-endif-to-ifdef ()
   "If positioned at #endif form, skip backward to corresponding #ifX."
 
 (defun hif-endif-to-ifdef ()
   "If positioned at #endif form, skip backward to corresponding #ifX."
- (message "hif-endif-to-ifdef at %d" (point))
+  ;; (message "hif-endif-to-ifdef at %d" (point))
   (let ((start (point)))
     (hif-find-previous-relevant)
     (if (= start (point))
   (let ((start (point)))
     (hif-find-previous-relevant)
     (if (= start (point))
@@ -598,18 +583,16 @@ NOT including one on this line."
 With argument, do this that many times."
   (interactive "p")
   (or arg (setq arg 1))
 With argument, do this that many times."
   (interactive "p")
   (or arg (setq arg 1))
-  (if (< arg 0)
-      (backward-ifdef (- arg)))
-  (while (< 0 arg)
-    (setq arg (- arg))
-    (let ((start (point)))
-      (if (not (hif-looking-at-ifX))
+  (if (< arg 0) (backward-ifdef (- arg))
+    (while (< 0 arg)
+      (setq arg (- arg))
+      (let ((start (point)))
+       (unless (hif-looking-at-ifX)
          (hif-find-next-relevant))
          (hif-find-next-relevant))
-      (if (hif-looking-at-ifX)
-         (hif-ifdef-to-endif)
-       (goto-char start)
-       (error "No following #ifdef")
-       ))))
+       (if (hif-looking-at-ifX)
+           (hif-ifdef-to-endif)
+         (goto-char start)
+         (error "No following #ifdef"))))))
 
 
 (defun backward-ifdef (&optional arg)
 
 
 (defun backward-ifdef (&optional arg)
@@ -617,18 +600,17 @@ With argument, do this that many times."
 With argument, do this that many times."
   (interactive "p")
   (or arg (setq arg 1))
 With argument, do this that many times."
   (interactive "p")
   (or arg (setq arg 1))
-  (if (< arg 0)
-      (forward-ifdef (- arg)))
-  (while (< 0 arg)
-    (setq arg (1- arg))
-    (beginning-of-line)
-    (let ((start (point)))
-      (if (not (hif-looking-at-endif))
+  (if (< arg 0) (forward-ifdef (- arg))
+    (while (< 0 arg)
+      (setq arg (1- arg))
+      (beginning-of-line)
+      (let ((start (point)))
+       (unless (hif-looking-at-endif)
          (hif-find-previous-relevant))
          (hif-find-previous-relevant))
-      (if (hif-looking-at-endif)
-         (hif-endif-to-ifdef)
-       (goto-char start)
-       (error "No previous #ifdef")))))
+       (if (hif-looking-at-endif)
+           (hif-endif-to-ifdef)
+         (goto-char start)
+         (error "No previous #ifdef"))))))
 
 
 (defun down-ifdef ()
 
 
 (defun down-ifdef ()
@@ -647,8 +629,8 @@ With argument, do this that many times."
   (interactive)
   (beginning-of-line)
   (let ((start (point)))
   (interactive)
   (beginning-of-line)
   (let ((start (point)))
-    (if (not (hif-looking-at-endif))
-       (hif-find-previous-relevant))
+    (unless (hif-looking-at-endif)
+      (hif-find-previous-relevant))
     (if (hif-looking-at-endif)
        (hif-endif-to-ifdef))
       (if (= start (point))
     (if (hif-looking-at-endif)
        (hif-endif-to-ifdef))
       (if (= start (point))
@@ -659,36 +641,32 @@ With argument, do this that many times."
 With argument, do this that many times."
   (interactive "p")
   (or arg (setq arg 1))
 With argument, do this that many times."
   (interactive "p")
   (or arg (setq arg 1))
-  (if (< arg 0)
-      (previous-ifdef (- arg)))
-  (while (< 0 arg)
-    (setq arg (1- arg))
-    (hif-find-next-relevant)
-    (if (eolp)
-       (progn
-         (beginning-of-line)
-         (error "No following #ifdefs, #elses, or #endifs")))))
+  (if (< arg 0) (previous-ifdef (- arg))
+    (while (< 0 arg)
+      (setq arg (1- arg))
+      (hif-find-next-relevant)
+      (when (eolp)
+       (beginning-of-line)
+       (error "No following #ifdefs, #elses, or #endifs")))))
 
 (defun previous-ifdef (&optional arg)
   "Move to the beginning of the previous #ifX, #else, or #endif.
 With argument, do this that many times."
   (interactive "p")
   (or arg (setq arg 1))
 
 (defun previous-ifdef (&optional arg)
   "Move to the beginning of the previous #ifX, #else, or #endif.
 With argument, do this that many times."
   (interactive "p")
   (or arg (setq arg 1))
-  (if (< arg 0)
-      (next-ifdef (- arg)))
-  (while (< 0 arg)
-    (setq arg (1- arg))
-    (let ((start (point)))
-      (hif-find-previous-relevant)
-      (if (= start (point))
-         (error "No previous #ifdefs, #elses, or #endifs")
-       ))))
+  (if (< arg 0) (next-ifdef (- arg))
+    (while (< 0 arg)
+      (setq arg (1- arg))
+      (let ((start (point)))
+       (hif-find-previous-relevant)
+       (if (= start (point))
+           (error "No previous #ifdefs, #elses, or #endifs"))))))
 
 
 
 
-;===%%SF%% parsing (End)  ===
+;;===%%SF%% parsing (End)  ===
 
 
 
 
-;===%%SF%% hide-ifdef-hiding (Start)  ===
+;;===%%SF%% hide-ifdef-hiding (Start)  ===
 
 
 ;;; A range is a structure with four components:
 
 
 ;;; A range is a structure with four components:
@@ -698,13 +676,12 @@ With argument, do this that many times."
 ;;;                    Only valid if ELSE-P is true.
 ;;; END                The end of the range.  (beginning of line)
 
 ;;;                    Only valid if ELSE-P is true.
 ;;; END                The end of the range.  (beginning of line)
 
-(defun hif-make-range (else-p start end &optional else)
-  (list else-p start else end))
+(defsubst hif-make-range (start end &optional else)
+  (list start else end))
 
 
-(defun hif-range-else-p (range)  (elt range 0))
-(defun hif-range-start (range) (elt range 1))
-(defun hif-range-else (range) (elt range 2))
-(defun hif-range-end (range) (elt range 3))
+(defsubst hif-range-start (range) (elt range 0))
+(defsubst hif-range-else (range) (elt range 1))
+(defsubst hif-range-end (range) (elt range 2))
 
 
 
 
 
 
@@ -714,68 +691,53 @@ With argument, do this that many times."
 ;;; an #else was found, skip some more, looking for the true #endif.
 
 (defun hif-find-range ()
 ;;; an #else was found, skip some more, looking for the true #endif.
 
 (defun hif-find-range ()
-  "Returns a Range structure describing the current #if region.
+  "Return a Range structure describing the current #if region.
 Point is left unchanged."
 Point is left unchanged."
- (message "hif-find-range at %d" (point))
+  ;; (message "hif-find-range at %d" (point))
   (save-excursion
     (beginning-of-line)
     (let ((start (point))
   (save-excursion
     (beginning-of-line)
     (let ((start (point))
-         (else-p nil)
          (else nil)
          (end nil))
       ;; Part one.  Look for either #endif or #else.
       ;; This loop-and-a-half dedicated to E. Dijkstra.
          (else nil)
          (end nil))
       ;; Part one.  Look for either #endif or #else.
       ;; This loop-and-a-half dedicated to E. Dijkstra.
-      (hif-find-next-relevant)
-      (while (hif-looking-at-ifX)              ; Skip nested ifdef
-       (hif-ifdef-to-endif)
-       (hif-find-next-relevant))
+      (while (progn
+              (hif-find-next-relevant)
+              (hif-looking-at-ifX))            ; Skip nested ifdef
+       (hif-ifdef-to-endif))
       ;; Found either a #else or an #endif.
       (cond ((hif-looking-at-else)
       ;; Found either a #else or an #endif.
       (cond ((hif-looking-at-else)
-            (setq else-p t)
             (setq else (point)))
            (t
             (setq else (point)))
            (t
-            (setq end (point)) ; (save-excursion (end-of-line) (point))
-            ))
+            (setq end (point)))) ; (save-excursion (end-of-line) (point))
       ;; If found #else, look for #endif.
       ;; If found #else, look for #endif.
-      (if else-p
-         (progn
-           (hif-find-next-relevant)
-           (while (hif-looking-at-ifX) ; Skip nested ifdef
-             (hif-ifdef-to-endif)
-             (hif-find-next-relevant))
-           (if (hif-looking-at-else)
-               (error "Found two elses in a row?  Broken!"))
-           (setq end (point))  ; (save-excursion (end-of-line) (point))
-           ))
-      (hif-make-range else-p start end else))))
+      (when else
+       (while (progn
+                (hif-find-next-relevant)
+                (hif-looking-at-ifX))  ; Skip nested ifdef
+         (hif-ifdef-to-endif))
+       (if (hif-looking-at-else)
+           (error "Found two elses in a row?  Broken!"))
+       (setq end (point)))            ; (save-excursion (end-of-line) (point))
+      (hif-make-range start end else))))
+
 
 
-         
 ;;; A bit slimy.
 ;;; A bit slimy.
-;;; NOTE:  If there's an #ifdef at the beginning of the file, we can't
-;;; hide it.  There's no previous newline to replace.  If we added
-;;; one, we'd throw off all the counts.  Feh.
 
 (defun hif-hide-line (point)
   "Hide the line containing point.  Does nothing if `hide-ifdef-lines' is nil."
   (if hide-ifdef-lines
       (save-excursion
        (goto-char point)
 
 (defun hif-hide-line (point)
   "Hide the line containing point.  Does nothing if `hide-ifdef-lines' is nil."
   (if hide-ifdef-lines
       (save-excursion
        (goto-char point)
-       (let ((modp (buffer-modified-p)))
-         (unwind-protect
-             (progn
-               (beginning-of-line)
-               (if (not (= (point) 1))
-                   (hide-ifdef-region (1- (point)) (point))))
-           (set-buffer-modified-p modp))
-         ))
-    ))
-                 
+       (hide-ifdef-region-internal (line-beginning-position)
+                                   (progn (hif-end-of-line) (point))))))
+
 
 ;;;  Hif-Possibly-Hide
 ;;;  There are four cases.  The #ifX expression is "taken" if it
 ;;;  the hide-ifdef-evaluator returns T.  Presumably, this means the code
 ;;;  inside the #ifdef would be included when the program was
 
 ;;;  Hif-Possibly-Hide
 ;;;  There are four cases.  The #ifX expression is "taken" if it
 ;;;  the hide-ifdef-evaluator returns T.  Presumably, this means the code
 ;;;  inside the #ifdef would be included when the program was
-;;;  compiled.  
+;;;  compiled.
 ;;;
 ;;;  Case 1:  #ifX taken, and there's an #else.
 ;;;    The #else part must be hidden.  The #if (then) part must be
 ;;;
 ;;;  Case 1:  #ifX taken, and there's an #else.
 ;;;    The #else part must be hidden.  The #if (then) part must be
@@ -804,101 +766,97 @@ Point is left unchanged."
       (hide-ifdef-guts))))
 
 (defun hif-possibly-hide ()
       (hide-ifdef-guts))))
 
 (defun hif-possibly-hide ()
-  "Called at #ifX expression, this hides those parts that should be
-hidden, according to judgement of `hide-ifdef-evaluator'."
-;  (message "hif-possibly-hide") (sit-for 1)
-    (let ((test (hif-canonicalize))
-         (range (hif-find-range)))
-;      (message "test = %s" test) (sit-for 1)
-      
-      (hif-hide-line (hif-range-end range))
-      (if (funcall hide-ifdef-evaluator test)
-         (cond ((hif-range-else-p range) ; case 1
-                (hif-hide-line (hif-range-else range))
-                (hide-ifdef-region (hif-range-else range) 
-                                   (1- (hif-range-end range)))
-                (hif-recurse-on (hif-range-start range)
-                                (hif-range-else range)))
-               (t ; case 2
-                (hif-recurse-on (hif-range-start range)
-                                (hif-range-end range))))
-       (cond ((hif-range-else-p range) ; case 3
+  "Called at #ifX expression, this hides those parts that should be hidden.
+It uses the judgement of `hide-ifdef-evaluator'."
+  ;; (message "hif-possibly-hide") (sit-for 1)
+  (let ((test (hif-canonicalize))
+       (range (hif-find-range)))
+    ;; (message "test = %s" test) (sit-for 1)
+
+    (hif-hide-line (hif-range-end range))
+    (if (not (hif-not (funcall hide-ifdef-evaluator test)))
+       (cond ((hif-range-else range)   ; case 1
               (hif-hide-line (hif-range-else range))
               (hif-hide-line (hif-range-else range))
-              (hide-ifdef-region (hif-range-start range)
-                                 (1- (hif-range-else range)))
-              (hif-recurse-on (hif-range-else range)
-                              (hif-range-end range)))
-             (t ; case 4
-              (hide-ifdef-region (point)
-                                 (1- (hif-range-end range))))
-             ))
-      (hif-hide-line (hif-range-start range))  ; Always hide start.
-      (goto-char (hif-range-end range))
-      (end-of-line)
-      ))
+              (hide-ifdef-region (hif-range-else range)
+                                 (1- (hif-range-end range)))
+              (hif-recurse-on (hif-range-start range)
+                              (hif-range-else range)))
+             (t                        ; case 2
+              (hif-recurse-on (hif-range-start range)
+                              (hif-range-end range))))
+      (cond ((hif-range-else range)    ; case 3
+            (hif-hide-line (hif-range-else range))
+            (hide-ifdef-region (hif-range-start range)
+                               (1- (hif-range-else range)))
+            (hif-recurse-on (hif-range-else range)
+                            (hif-range-end range)))
+           (t                          ; case 4
+            (hide-ifdef-region (point)
+                               (1- (hif-range-end range))))))
+    (hif-hide-line (hif-range-start range)) ; Always hide start.
+    (goto-char (hif-range-end range))
+    (end-of-line)))
 
 
 
 (defun hide-ifdef-guts ()
 
 
 
 (defun hide-ifdef-guts ()
-  "Does the work of `hide-ifdefs', except for the work that's pointless
-to redo on a recursive entry."
- (message "hide-ifdef-guts")
+  "Does most of the work of `hide-ifdefs'.
+It does not do the work that's pointless to redo on a recursive entry."
+  ;; (message "hide-ifdef-guts")
   (save-excursion
     (goto-char (point-min))
     (while (hif-find-any-ifX)
       (hif-possibly-hide))))
 
   (save-excursion
     (goto-char (point-min))
     (while (hif-find-any-ifX)
       (hif-possibly-hide))))
 
-;===%%SF%% hide-ifdef-hiding (End)  ===
+;;===%%SF%% hide-ifdef-hiding (End)  ===
 
 
 
 
-;===%%SF%% exports (Start)  ===
+;;===%%SF%% exports (Start)  ===
 
 ;;;###autoload
 
 ;;;###autoload
-(defvar hide-ifdef-initially nil
-  "*Non-nil if `hide-ifdefs' should be called when Hide-Ifdef mode
-is first activated.")
-
-(defvar hide-ifdef-hiding nil
-  "Non-nil if text might be hidden.")
+(defcustom hide-ifdef-initially nil
+  "*Non-nil means call `hide-ifdefs' when Hide-Ifdef mode is first activated."
+  :type 'boolean
+  :group 'hide-ifdef)
 
 ;;;###autoload
 
 ;;;###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
 
 ;;;###autoload
-(defvar hide-ifdef-lines nil
-  "*Set to t if you don't want to see 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 ()
 
 (defun hide-ifdef-toggle-read-only ()
-  "Toggle hide-ifdef-read-only."
+  "Toggle `hide-ifdef-read-only'."
   (interactive)
   (setq hide-ifdef-read-only (not hide-ifdef-read-only))
   (message "Hide-Read-Only %s"
           (if hide-ifdef-read-only "ON" "OFF"))
   (if hide-ifdef-hiding
       (setq buffer-read-only (or hide-ifdef-read-only hif-outside-read-only)))
   (interactive)
   (setq hide-ifdef-read-only (not hide-ifdef-read-only))
   (message "Hide-Read-Only %s"
           (if hide-ifdef-read-only "ON" "OFF"))
   (if hide-ifdef-hiding
       (setq buffer-read-only (or hide-ifdef-read-only hif-outside-read-only)))
-  (hif-update-mode-line))
+  (force-mode-line-update))
 
 (defun hide-ifdef-toggle-outside-read-only ()
 
 (defun hide-ifdef-toggle-outside-read-only ()
-  "Replacement for `toggle-read-only' within Hide Ifdef mode."
+  "Replacement for `toggle-read-only' within Hide-Ifdef mode."
   (interactive)
   (setq hif-outside-read-only (not hif-outside-read-only))
   (message "Read only %s"
           (if hif-outside-read-only "ON" "OFF"))
   (setq buffer-read-only
        (or (and hide-ifdef-hiding hide-ifdef-read-only)
   (interactive)
   (setq hif-outside-read-only (not hif-outside-read-only))
   (message "Read only %s"
           (if hif-outside-read-only "ON" "OFF"))
   (setq buffer-read-only
        (or (and hide-ifdef-hiding hide-ifdef-read-only)
-           hif-outside-read-only)
-       )
-  (hif-update-mode-line))
+           hif-outside-read-only))
+  (force-mode-line-update))
+
 
 
-      
 (defun hide-ifdef-define (var)
   "Define a VAR so that #ifdef VAR would be included."
   (interactive "SDefine what? ")
 (defun hide-ifdef-define (var)
   "Define a VAR so that #ifdef VAR would be included."
   (interactive "SDefine what? ")
-  (hif-set-var var t)
+  (hif-set-var var 1)
   (if hide-ifdef-hiding (hide-ifdefs)))
 
 (defun hide-ifdef-undef (var)
   (if hide-ifdef-hiding (hide-ifdefs)))
 
 (defun hide-ifdef-undef (var)
@@ -908,9 +866,9 @@ is first activated.")
   (if hide-ifdef-hiding (hide-ifdefs)))
 
 
   (if hide-ifdef-hiding (hide-ifdefs)))
 
 
-(defun hide-ifdefs ()
-  "Hide the contents of some #ifdefs.  
-Assume that defined symbols have been added to `hide-ifdef-env'.  
+(defun hide-ifdefs (&optional nomsg)
+  "Hide the contents of some #ifdefs.
+Assume that defined symbols have been added to `hide-ifdef-env'.
 The text hidden is the text that would not be included by the C
 preprocessor if it were given the file with those symbols defined.
 
 The text hidden is the text that would not be included by the C
 preprocessor if it were given the file with those symbols defined.
 
@@ -918,115 +876,106 @@ Turn off hiding by calling `show-ifdefs'."
 
   (interactive)
   (message "Hiding...")
 
   (interactive)
   (message "Hiding...")
-  (if (not hide-ifdef-mode)
-      (hide-ifdef-mode 1)) ; turn on hide-ifdef-mode
+  (setq hif-outside-read-only buffer-read-only)
+  (unless hide-ifdef-mode (hide-ifdef-mode 1)) ; turn on hide-ifdef-mode
   (if hide-ifdef-hiding
       (show-ifdefs))                   ; Otherwise, deep confusion.
   (if hide-ifdef-hiding
       (show-ifdefs))                   ; Otherwise, deep confusion.
-  (let ((inhibit-read-only t))
-    (setq selective-display t)
-    (setq hide-ifdef-hiding t)
-    (hide-ifdef-guts))
+  (setq hide-ifdef-hiding t)
+  (hide-ifdef-guts)
   (setq buffer-read-only (or hide-ifdef-read-only hif-outside-read-only))
   (setq buffer-read-only (or hide-ifdef-read-only hif-outside-read-only))
-  (message "Hiding done"))
+  (or nomsg
+      (message "Hiding done")))
 
 
 (defun show-ifdefs ()
 
 
 (defun show-ifdefs ()
-  "Cancel the effects of `hide-ifdef'.  The contents of all #ifdefs is shown."
+  "Cancel the effects of `hide-ifdef': show the contents of all #ifdefs."
   (interactive)
   (setq buffer-read-only hif-outside-read-only)
   (interactive)
   (setq buffer-read-only hif-outside-read-only)
-  (setq selective-display nil) ; defaults
-  (let ((inhibit-read-only t))
-    (hif-show-all))
+  (hif-show-all)
   (setq hide-ifdef-hiding nil))
 
 
 (defun hif-find-ifdef-block ()
   "Utility for hide and show `ifdef-block'.
   (setq hide-ifdef-hiding nil))
 
 
 (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)
   (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)
+           (unless (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)
+           (unless (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 ()
   "Hide the ifdef block (true or false part) enclosing or before the cursor."
   (interactive)
 
 
 (defun hide-ifdef-block ()
   "Hide the ifdef block (true or false part) enclosing or before the cursor."
   (interactive)
-  (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)
-    (if hide-ifdef-lines
-       (progn
-         (hif-hide-line top)
-         (hif-hide-line (1+ bottom))))
+  (unless hide-ifdef-mode (hide-ifdef-mode 1))
+  (let ((top-bottom (hif-find-ifdef-block)))
+    (hide-ifdef-region (car top-bottom) (cdr top-bottom))
+    (when hide-ifdef-lines
+      (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)))
 
     (setq hide-ifdef-hiding t))
   (setq buffer-read-only (or hide-ifdef-read-only hif-outside-read-only)))
 
-
 (defun show-ifdef-block ()
   "Show the ifdef block (true or false part) enclosing or before the cursor."
   (interactive)
 (defun show-ifdef-block ()
   "Show the ifdef block (true or false part) enclosing or before the cursor."
   (interactive)
-  (let ((inhibit-read-only t))
+  (let ((top-bottom (hif-find-ifdef-block)))
     (if hide-ifdef-lines
     (if hide-ifdef-lines
-       (save-excursion
-         (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)))))
+       (hif-show-ifdef-region
+        (save-excursion
+          (goto-char (car top-bottom)) (line-beginning-position))
+        (save-excursion
+          (goto-char (1+ (cdr top-bottom)))
+          (hif-end-of-line) (point)))
+      (hif-show-ifdef-region (1- (car top-bottom)) (cdr top-bottom)))))
 
 
 ;;;  definition alist support
 
 (defvar hide-ifdef-define-alist nil
 
 
 ;;;  definition alist support
 
 (defvar hide-ifdef-define-alist nil
-  "A global assoc list of pre-defined symbol lists")
+  "A global assoc list of pre-defined symbol lists.")
 
 (defun hif-compress-define-list (env)
   "Compress the define list ENV into a list of defined symbols only."
 
 (defun hif-compress-define-list (env)
   "Compress the define list ENV into a list of defined symbols only."
-  (let ((defs (mapcar '(lambda (arg)
-                        (if (hif-lookup (car arg)) (car arg)))
-                     env))
-       (new-defs nil))
-    (while defs
-      (if (car defs)
-         (setq new-defs (cons (car defs) new-defs)))
-      (setq defs (cdr defs)))
-    new-defs))
+  (let ((new-defs nil))
+    (dolist (def env new-defs)
+      (if (hif-lookup (car def)) (push (car env) new-defs)))))
 
 (defun hide-ifdef-set-define-alist (name)
   "Set the association for NAME to `hide-ifdef-env'."
   (interactive "SSet define list: ")
 
 (defun hide-ifdef-set-define-alist (name)
   "Set the association for NAME to `hide-ifdef-env'."
   (interactive "SSet define list: ")
-  (setq hide-ifdef-define-alist
-       (cons (cons name (hif-compress-define-list hide-ifdef-env))
-             hide-ifdef-define-alist)))
+  (push (cons name (hif-compress-define-list hide-ifdef-env))
+       hide-ifdef-define-alist))
 
 (defun hide-ifdef-use-define-alist (name)
   "Set `hide-ifdef-env' to the define list specified by NAME."
 
 (defun hide-ifdef-use-define-alist (name)
   "Set `hide-ifdef-env' to the define list specified by NAME."
-  (interactive "SUse define list: ")
+  (interactive
+   (list (completing-read "Use define list: "
+                         (mapcar (lambda (x) (symbol-name (car x)))
+                                  hide-ifdef-define-alist)
+                          nil t)))
+  (if (stringp name) (setq name (intern name)))
   (let ((define-list (assoc name hide-ifdef-define-alist)))
     (if define-list
        (setq hide-ifdef-env
   (let ((define-list (assoc name hide-ifdef-define-alist)))
     (if define-list
        (setq hide-ifdef-env
-             (mapcar '(lambda (arg) (cons arg t))
+             (mapcar (lambda (arg) (cons arg t))
                      (cdr define-list)))
       (error "No define list for %s" name))
     (if hide-ifdef-hiding (hide-ifdefs))))
 
                      (cdr define-list)))
       (error "No define list for %s" name))
     (if hide-ifdef-hiding (hide-ifdefs))))
 
-;;; hideif.el ends here
+(provide 'hideif)
 
 
+;; arch-tag: c6381d17-a59a-483a-b945-658f22277981
+;;; hideif.el ends here