| blob | 4b78c08690a084b3adf3ae4cb7c955a923cc7cfd |
1 ;;; hideif.el --- hides selected code within ifdef
3 ;; Copyright (C) 1988, 1994, 2001-2014 Free Software Foundation, Inc.
5 ;; Author: Brian Marick
6 ;; Daniel LaLiberte <liberte@holonexus.org>
7 ;; Maintainer: emacs-devel@gnu.org
8 ;; Keywords: c, outlines
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is free software: you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation, either version 3 of the License, or
15 ;; (at your option) any later version.
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
25 ;;; Commentary:
27 ;; To initialize, toggle the hide-ifdef minor mode with
28 ;;
29 ;; M-x hide-ifdef-mode
30 ;;
31 ;; This will set up key bindings and call hide-ifdef-mode-hook if it
32 ;; has a value. To explicitly hide ifdefs using a buffer-local
33 ;; define list (default empty), type
34 ;;
35 ;; M-x hide-ifdefs or C-c @ h
36 ;;
37 ;; Hide-ifdef suppresses the display of code that the preprocessor wouldn't
38 ;; pass through. Support complete C/C++ expression and precedence.
39 ;; It will automatically scan for new #define symbols and macros on the way
40 ;; parsing.
41 ;;
42 ;; The hidden code is marked by ellipses (...). Be
43 ;; cautious when editing near ellipses, since the hidden text is
44 ;; still in the buffer, and you can move the point into it and modify
45 ;; text unawares.
46 ;; You can make your buffer read-only while hide-ifdef-hiding by setting
47 ;; hide-ifdef-read-only to a non-nil value. You can toggle this
48 ;; variable with hide-ifdef-toggle-read-only (C-c @ C-q).
49 ;;
50 ;; You can undo the effect of hide-ifdefs by typing
51 ;;
52 ;; M-x show-ifdefs or C-c @ s
53 ;;
54 ;; Use M-x hide-ifdef-define (C-c @ d) to define a symbol.
55 ;; Use M-x hide-ifdef-undef (C-c @ u) to undefine a symbol.
56 ;;
57 ;; If you define or undefine a symbol while hide-ifdef-mode is in effect,
58 ;; the display will be updated. Only the define list for the current
59 ;; buffer will be affected. You can save changes to the local define
60 ;; list with hide-ifdef-set-define-alist. This adds entries
61 ;; to hide-ifdef-define-alist.
62 ;;
63 ;; If you have defined a hide-ifdef-mode-hook, you can set
64 ;; up a list of symbols that may be used by hide-ifdefs as in the
65 ;; following example:
66 ;;
67 ;; (add-hook 'hide-ifdef-mode-hook
68 ;; (lambda ()
69 ;; (unless hide-ifdef-define-alist
70 ;; (setq hide-ifdef-define-alist
71 ;; '((list1 ONE TWO)
72 ;; (list2 TWO THREE))))
73 ;; (hide-ifdef-use-define-alist 'list2))) ; use list2 by default
74 ;;
75 ;; You can call hide-ifdef-use-define-alist (C-c @ U) at any time to specify
76 ;; another list to use.
77 ;;
78 ;; To cause ifdefs to be hidden as soon as hide-ifdef-mode is called,
79 ;; set hide-ifdef-initially to non-nil.
80 ;;
81 ;; If you set hide-ifdef-lines to t, hide-ifdefs hides all the #ifdef lines.
82 ;; In the absence of highlighting, that might be a bad idea. If you set
83 ;; hide-ifdef-lines to nil (the default), the surrounding preprocessor
84 ;; lines will be displayed. That can be confusing in its own
85 ;; right. Other variations on display are possible, but not much
86 ;; better.
87 ;;
88 ;; You can explicitly hide or show individual ifdef blocks irrespective
89 ;; of the define list by using hide-ifdef-block and show-ifdef-block.
90 ;;
91 ;; You can move the point between ifdefs with forward-ifdef, backward-ifdef,
92 ;; up-ifdef, down-ifdef, next-ifdef, and previous-ifdef.
93 ;;
94 ;; If you have minor-mode-alist in your mode line (the default) two labels
95 ;; may appear. "Ifdef" will appear when hide-ifdef-mode is active. "Hiding"
96 ;; will appear when text may be hidden ("hide-ifdef-hiding" is non-nil).
97 ;;
98 ;; Written by Brian Marick, at Gould, Computer Systems Division, Urbana IL.
99 ;; Extensively modified by Daniel LaLiberte (while at Gould).
100 ;;
101 ;; Extensively modified by Luke Lee in 2013 to support complete C expression
102 ;; evaluation and argumented macro expansion.
104 ;;; Code:
110 "Hide selected code within `ifdef'."
114 "Non-nil means call `hide-ifdefs' when Hide-Ifdef mode is first activated."
119 "Set to non-nil if you want buffer to be read-only while hiding text."
124 "Non-nil means hide the #ifX, #else, and #endif lines."
129 "Non-nil means shadow text instead of hiding it."
135 "Face for shadowing ifdef blocks."
140 "Ignore #define names if those names match this exclusion pattern."
144 ;; Set up the submap that goes after the prefix key.
160 map)
167 ;; Set up the mode's main map, which leads via the prefix key to the submap.
170 map)
174 "Menu for `hide-ifdef-mode'."
205 minor-mode-alist)))
207 ;; Fix c-mode syntax table so we can recognize whole symbols.
213 st)
222 ;;;###autoload
224 "Toggle features to hide/show #ifdef blocks (Hide-Ifdef mode).
225 With a prefix argument ARG, enable Hide-Ifdef mode if ARG is
226 positive, and disable it otherwise. If called from Lisp, enable
227 the mode if ARG is omitted or nil.
229 Hide-Ifdef mode is a buffer-local minor mode for use with C and
230 C-like major modes. When enabled, code within #ifdef constructs
231 that the C preprocessor would eliminate may be hidden from view.
232 Several variables affect how the hiding is done:
234 `hide-ifdef-env'
235 An association list of defined and undefined symbols for the
236 current buffer. Initially, the global value of `hide-ifdef-env'
237 is used.
239 `hide-ifdef-define-alist'
240 An association list of defined symbol lists.
241 Use `hide-ifdef-set-define-alist' to save the current `hide-ifdef-env'
242 and `hide-ifdef-use-define-alist' to set the current `hide-ifdef-env'
243 from one of the lists in `hide-ifdef-define-alist'.
245 `hide-ifdef-lines'
246 Set to non-nil to not show #if, #ifdef, #ifndef, #else, and
247 #endif lines when hiding.
249 `hide-ifdef-initially'
250 Indicates whether `hide-ifdefs' should be called when Hide-Ifdef mode
251 is activated.
253 `hide-ifdef-read-only'
254 Set to non-nil if you want to make buffers read only while hiding.
255 After `show-ifdefs', read-only status is restored to previous value.
261 ;; inherit global values
276 ;; else end hide-ifdef-mode
284 "Show all of the text in the current buffer."
288 ;; By putting this on after-revert-hook, we arrange that it only
289 ;; does anything when revert-buffer avoids turning off the mode.
290 ;; (That can happen in VC.)
310 "START is the start of a #if or #else form. END is the ending part.
311 Everything including these lines is made invisible."
318 "Everything between START and END is made visible."
322 ;;===%%SF%% evaluation (Start) ===
324 ;; It is not useful to set this to anything but `eval'.
325 ;; In fact, the variable might as well be eliminated.
327 "The function to use to evaluate a form.
328 The evaluator is given a canonical form and returns t if text under
336 "Prepend (VAR VALUE) pair to `hide-ifdef-env'."
348 hif-undefined-symbol))))
357 ;;===%%SF%% evaluation (End) ===
361 ;;===%%SF%% parsing (Start) ===
362 ;;; The code that understands what ifs and ifdef in files look like.
373 hif-endif-regexp))
385 "(" hif-white-regexp
389 ")"
392 ;; Store the current token and the whole token list during parsing.
393 ;; Bound dynamically.
406 ;; Note: we include tokens like `=' which aren't supported by CPP's
407 ;; expression syntax, because they are still relevant for the tokenizer,
408 ;; especially in conjunction with ##.
442 "Like `string-to-number', but it understands non-decimal floats."
449 base
453 ;; The dynamic binding variable `hif-simple-token-only' is shared only by
454 ;; `hif-tokenize' and `hif-find-define'. The purpose is to prevent `hif-tokenize'
455 ;; from returning one more value to indicate a simple token is scanned. This help
456 ;; speeding up macro evaluation on those very simple cases like integers or
457 ;; literals.
458 ;; Check the long comments before `hif-find-define' for more details. [lukelee]
462 "Separate string between START and END into a list of tokens."
469 ;; (message "expr-start = %d" expr-start) (sit-for 1)
482 ;; (message "token: %s" token) (sit-for 1)
486 ;; TODO:
487 ;; 1. postfix 'l', 'll', 'ul' and 'ull'
488 ;; 2. floating number formats (like 1.23e4)
489 ;; 3. 098 is interpreted as octal conversion error
491 token)
496 token)
500 token-list)))
506 ;;------------------------------------------------------------------------
507 ;; Translate C preprocessor #if expressions using recursive descent.
508 ;; This parser was limited to the operators &&, ||, !, and "defined".
509 ;; Added ==, !=, +, and -. Gary Oberbrunner, garyo@avs.com, 8/9/94
510 ;;
511 ;; Implement the C language operator precedence table. Add all those
512 ;; missing operators that could be used in macros. Luke Lee 2013-09-04
514 ;; | Operator Type | Operator | Associativity |
515 ;; +----------------------+-----------------------------+---------------+
516 ;; | Primary Expression | () [] . -> expr++ expr-- | left-to-right |
517 ;; | Unary Operators | * & + - ! ~ ++expr --expr | right-to-left |
518 ;; | | (typecast) sizeof | |
519 ;; | Binary Operators | * / % | left-to-right |
520 ;; | | + - | |
521 ;; | | >> << | |
522 ;; | | < > <= >= | |
523 ;; | | == != | |
524 ;; | | & | |
525 ;; | | ^ | |
526 ;; | | | | |
527 ;; | | && | |
528 ;; | | || | |
529 ;; | Ternary Operator | ?: | right-to-left |
530 ;; x| Assignment Operators | = += -= *= /= %= >>= <<= &= | right-to-left |
531 ;; | | ^= = | |
532 ;; | Comma | , | left-to-right |
535 "Pop the next token from token-list into the let variable `hif-token'."
543 "`Upgrade' hif-define xxx to '(hif-define xxx)' so it won't be subsitituted."
561 tok)
562 result))
566 "Flatten a tree."
573 "Perform expansion on TOKENS till everything expanded.
574 Self-reference (directly or indirectly) tokens are not expanded.
575 EXPAND_LIST is the list of macro names currently being expanded, use for
576 detecting self-reference."
582 tok rep)
585 ;; Expanding all tokens till list exhausted
588 ;; For self-referencing tokens, don't expand it
595 tok)
600 ;; Recursively expand it
603 ;; No argument, no invocation
604 tok
605 ;; Argumented macro, get arguments and invoke it.
606 ;; Dynamically bind hif-token-list and hif-token
607 ;; for hif-macro-supply-arguments
612 tok)))
616 tok expand_list)))
618 result))
619 ;; Argument list is nil, direct expansion
622 tok expand_list))
623 ;; Replace all remaining references immediately
625 rep)
626 ;; Lookup tok returns an atom
627 rep))
629 ;;[2013-10-22 16:06:12 +0800] Must keep the token, removing
630 ;; this token might results in an incomplete expression that
631 ;; cannot be parsed further.
632 ;;((= 1 (hif-defined tok)) ; defined (hif-defined tok)=1,
633 ;; ;;but empty (hif-lookup tok)=nil, thus remove this token
634 ;; (setq remains (delete tok remains))
635 ;; nil)
638 tok))
640 expanded))
645 "Parse the TOKEN-LIST.
646 Return translated list in prefix form. MACRONAME is applied when invoking
647 macros to prevent self-reference."
657 "Parse an exprlist: expr { ',' expr}."
667 result)))
670 "Parse an expression as found in #if.
671 expr : or-expr | or-expr '?' expr ':' expr."
673 middle)
682 result))
685 "Parse an or-expr : and-expr | or-expr '||' and-expr."
690 result))
693 "Parse an and-expr : logior-expr | and-expr '&&' logior-expr."
698 result))
701 "Parse a logor-expr : logxor-expr | logor-expr '|' logxor-expr."
706 result))
709 "Parse a logxor-expr : logand-expr | logxor-expr '^' logand-expr."
714 result))
717 "Parse a logand-expr : eq-expr | logand-expr '&' eq-expr."
722 result))
725 "Parse an eq-expr : comp | eq-expr `=='|`!=' comp."
732 result))
735 "Parse a comp-expr : logshift | comp-expr `<'|`>'|`>='|`<=' logshift."
739 hif-less-equal))
743 result))
746 "Parse a logshift : math | logshift `<<'|`>>' math."
753 result))
756 "Parse an expression with + or -.
757 math : muldiv | math '+|-' muldiv."
764 result))
767 "Parse an expression with *,/,%.
768 muldiv : factor | muldiv '*|/|%' factor."
775 result))
778 "Parse a factor.
779 factor : '!' factor | '~' factor | '(' expr ')' | 'defined(' id ')' |
780 'id(parmlist)' | strings | id."
796 result)))
816 ;; Unary plus/minus.
856 "Parse concatenated strings: string | strings string."
862 result))
865 "A marker for defined macro with arguments.
866 This macro cannot be evaluated alone without parameters inputed."
867 ;;TODO: input arguments at run time, use minibuffer to query all arguments
872 "Stringify a number, string or symbol."
888 "Concatenate two tokens into a longer token.
889 Currently support only simple token concatenation. Also support weird (but
890 valid) token concatenation like '>' ## '>' becomes '>>'. Here we take care only
891 those that can be evaluated during preprocessing time and ignore all those that
892 can only be evaluated at C(++) runtime (like '++', '--' and '+='...)."
900 ;;(error "Invalid token to concatenate")
902 preprocessing token"
909 "Treat VAL as a number: if it's t or nil, use 1 or 0."
962 "Evaluate a list of EXPR, return the result of the last item."
967 result))
970 "Scan token list for `hif-stringify' ('#') token and stringify the next token."
980 result)
985 "Scan token list for `hif-token-concat' ('##') token and concatenate two tokens."
987 result)
1002 result)))
1009 ;; Perform token replacement:
1011 "Expand a macro call, replace ACTUAL-PARMS in the macro body."
1019 actual-count
1020 formal-count
1021 actual
1022 formal
1023 etc)
1026 ;; For each actual parameter, evaluate each one and associate it
1027 ;; with an actual parameter, put it into local table and finally
1028 ;; evaluate the macro body.
1030 ;; Take care of `hif-etc' first. Prefix `hif-comma' back if needed.
1041 ;; Perform token replacement on the MACRO-BODY with the parameters
1043 ;; Prevent repetitive substitutation, thus cannot use `subst'
1044 ;; for example:
1045 ;; #define mac(a,b) (a+b)
1046 ;; #define testmac mac(b,y)
1047 ;; testmac should expand to (b+y): replace of argument a and b
1048 ;; occurs simultaneously, not sequentially. If sequentially,
1049 ;; according to the argument order, it will become:
1050 ;; 1. formal parm #1 'a' replaced by actual parm 'b', thus (a+b)
1051 ;; becomes (b+b)
1052 ;; 2. formal parm #2 'b' replaced by actual parm 'y', thus (b+b)
1053 ;; becomes (y+y).
1055 ;; Unlike `subst', `substitute' replace only the top level
1056 ;; instead of the whole tree; more importantly, it's not
1057 ;; destructive.
1061 formal macro-body))
1064 ;; Replacement completed, flatten the whole token list
1067 ;; Stringification and token concatenation happens here
1071 "Invoke a macro by expanding it, reparse macro-body and finally invoke it."
1072 ;; Reparse the macro body and evaluate it
1076 macro-name)))
1078 ;;;----------- end of parser -----------------------
1082 "Return the expanded result of the scanned tokens."
1096 tokens)))
1099 "Return a Lisp expression for its condition by scanning current buffer.
1100 Do this when cursor is at the beginning of `regexp' (i.e. #ifX)."
1118 "Move to next #if..., or #ifndef, at point or after."
1119 ;; (message "find ifX at %d" (point))
1126 "Move to next #if..., #elif..., #else, or #endif, after the current line."
1127 ;; (message "hif-find-next-relevant at %d" (point))
1129 ;; Avoid infinite recursion by only going to line-beginning if match found
1134 "Move to previous #if..., #else, or #endif, before the current line."
1135 ;; (message "hif-find-previous-relevant at %d" (point))
1137 ;; Avoid infinite recursion by only going to line-beginning if match found
1154 "If positioned at #ifX, #elif, or #else form, skip to corresponding #endif."
1155 ;; (message "hif-ifdef-to-endif at %d" (point)) (sit-for 1)
1171 "If positioned at #endif form, skip backward to corresponding #ifX."
1172 ;; (message "hif-endif-to-ifdef at %d" (point))
1188 "Move point to beginning of line of the next ifdef-endif.
1189 With argument, do this that many times."
1205 "Move point to beginning of the previous ifdef-endif.
1206 With argument, do this that many times."
1223 "Move point to beginning of nested ifdef or else-part."
1228 ()
1234 "Move point to beginning of enclosing ifdef or else-part."
1246 "Move to the beginning of the next #ifX, #else, or #endif.
1247 With argument, do this that many times."
1259 "Move to the beginning of the previous #ifX, #else, or #endif.
1260 With argument, do this that many times."
1272 ;;===%%SF%% parsing (End) ===
1275 ;;===%%SF%% hide-ifdef-hiding (Start) ===
1278 ;;; A range is a structure with four components:
1279 ;;; ELSE-P True if there was an else clause for the ifdef.
1280 ;;; START The start of the range. (beginning of line)
1281 ;;; ELSE The else marker (beginning of line)
1282 ;;; Only valid if ELSE-P is true.
1283 ;;; END The end of the range. (beginning of line)
1294 ;;; Find-Range
1295 ;;; The workhorse, it delimits the #if region. Reasonably simple:
1296 ;;; Skip until an #else or #endif is found, remembering positions. If
1297 ;;; an #else was found, skip some more, looking for the true #endif.
1300 "Return a Range structure describing the current #if region.
1301 Point is left unchanged."
1302 ;; (message "hif-find-range at %d" (point))
1308 ;; Part one. Look for either #endif or #else.
1309 ;; This loop-and-a-half dedicated to E. Dijkstra.
1314 ;; Found either a #else or an #endif.
1319 ;; If found #else, look for #endif.
1331 ;; A bit slimy.
1334 "Hide the line containing point.
1335 Does nothing if `hide-ifdef-lines' is nil."
1343 ;;; Hif-Possibly-Hide
1344 ;;; There are four cases. The #ifX expression is "taken" if it
1345 ;;; the hide-ifdef-evaluator returns T. Presumably, this means the code
1346 ;;; inside the #ifdef would be included when the program was
1347 ;;; compiled.
1348 ;;;
1349 ;;; Case 1: #ifX taken, and there's an #else.
1350 ;;; The #else part must be hidden. The #if (then) part must be
1351 ;;; processed for nested #ifX's.
1352 ;;; Case 2: #ifX taken, and there's no #else.
1353 ;;; The #if part must be processed for nested #ifX's.
1354 ;;; Case 3: #ifX not taken, and there's an #else.
1355 ;;; The #if part must be hidden. The #else part must be processed
1356 ;;; for nested #ifs.
1357 ;;; Case 4: #ifX not taken, and there's no #else.
1358 ;;; The #ifX part must be hidden.
1359 ;;;
1360 ;;; Further processing is done by narrowing to the relevant region
1361 ;;; and just recursively calling hide-ifdef-guts.
1362 ;;;
1363 ;;; When hif-possibly-hide returns, point is at the end of the
1364 ;;; possibly-hidden range.
1367 "Call `hide-ifdef-guts' after narrowing to end of START line and END line."
1376 "Called at #ifX expression, this hides those parts that should be hidden.
1377 It uses the judgment of `hide-ifdef-evaluator'."
1378 ;; (message "hif-possibly-hide") (sit-for 1)
1381 ;; (message "test = %s" test) (sit-for 1)
1408 "Parse argument list formatted as '( arg1 [ , argn] [...] )'.
1409 The '...' is also included. Return a list of the arguments, if '...' exists the
1410 first arg will be `hif-etc'."
1415 etc result token)
1421 t)
1428 ;; The original version of hideif evaluates the macro early and store the
1429 ;; final values for the defined macro into the symbol database (aka
1430 ;; `hide-ifdef-env'). The evaluation process is "strings -> tokens -> parsed
1431 ;; tree -> [value]". (The square bracket refers to what's stored in in our
1432 ;; `hide-ifdef-env'.)
1433 ;;
1434 ;; This forbids the evaluation of an argumented macro since the parameters
1435 ;; are applied at run time. In order to support argumented macro I then
1436 ;; postponed the evaluation process one stage and store the "parsed tree"
1437 ;; into symbol database. The evaluation process was then "strings -> tokens
1438 ;; -> [parsed tree] -> value". Hideif therefore run slower since it need to
1439 ;; evaluate the parsed tree everytime when trying to expand the symbol. These
1440 ;; temporarily code changes are obsolete and not in Emacs source repository.
1441 ;;
1442 ;; Furthermore, CPP did allow partial expression to be defined in several
1443 ;; macros and later got concatenated into a complete expression and then
1444 ;; evaluate it. In order to match this behavior I had to postpone one stage
1445 ;; further, otherwise those partial expression will be fail on parsing and
1446 ;; we'll miss all macros that reference it. The evaluation process thus
1447 ;; became "strings -> [tokens] -> parsed tree -> value." This degraded the
1448 ;; performance since we need to parse tokens and evaluate them everytime
1449 ;; when that symbol is referenced.
1450 ;;
1451 ;; In real cases I found a lot portion of macros are "simple macros" that
1452 ;; expand to literals like integers or other symbols. In order to enhance
1453 ;; the performance I use this `hif-simple-token-only' to notify my code and
1454 ;; save the final [value] into symbol database. [lukelee]
1457 "Parse texts and retrieve all defines within the region MIN and MAX."
1469 ;; Ignore name (still need to return 't), or define the name
1472 name))
1479 ;; `hif-simple-token-only' is set/clear
1480 ;; only in this block
1482 ;; Prevent C statements like
1483 ;; 'do { ... } while (0)'
1486 ;; We can't just return nil here since
1487 ;; this will stop hideif from searching
1488 ;; for more #defines.
1491 start end)))))
1492 ;; For simple tokens we save only the parsed result;
1493 ;; otherwise we save the tokens and parse it after
1494 ;; parameter replacement
1496 ;; `hif-simple-token-only' is checked only
1497 ;; here.
1509 ;; Lazy evaluation, eval only if hif-lookup find it.
1510 ;; Define it anyway, even if nil it's still in list
1511 ;; and therefore considerred defined
1513 ;; #undef
1516 t))
1520 "Scan and add all #define macros between MIN and MAX."
1524 ;; (mark-region min max) ;; for debugging
1531 "Does most of the work of `hide-ifdefs'.
1532 It does not do the work that's pointless to redo on a recursive entry."
1533 ;; (message "hide-ifdef-guts")
1536 min max)
1545 while max))))
1547 ;;===%%SF%% hide-ifdef-hiding (End) ===
1550 ;;===%%SF%% exports (Start) ===
1553 "Toggle `hide-ifdef-read-only'."
1560 hif-outside-read-only)))
1564 "Replacement for `toggle-read-only' within Hide-Ifdef mode."
1571 hif-outside-read-only))
1575 "Toggle shadowing."
1591 "Define a VAR so that #ifdef VAR would be included."
1602 "Undefine a VAR so that #ifdef VAR would not be included."
1617 "Hide the contents of some #ifdefs.
1618 Assume that defined symbols have been added to `hide-ifdef-env'.
1619 The text hidden is the text that would not be included by the C
1620 preprocessor if it were given the file with those symbols defined.
1622 Turn off hiding by calling `show-ifdefs'."
1638 "Cancel the effects of `hide-ifdef': show the contents of all #ifdefs."
1646 "Utility to hide and show ifdef block.
1647 Return as (TOP . BOTTOM) the extent of ifdef block."
1667 "Hide the ifdef block (true or false part) enclosing or before the cursor."
1679 "Show the ifdef block (true or false part) enclosing or before the cursor."
1692 ;;; definition alist support
1698 "Compress the define list ENV into a list of defined symbols only."
1704 "Set the association for NAME to `hide-ifdef-env'."
1707 hide-ifdef-define-alist))
1710 "Set `hide-ifdef-env' to the define list specified by NAME."
1714 hide-ifdef-define-alist)
1715 nil t)))
1727 ;;; hideif.el ends here