| blob | a9376ff6101a95c2ffc5b7b037a64f088472996d |
1 ;;; hideif.el --- hides selected code within ifdef -*- lexical-binding:t -*-
3 ;; Copyright (C) 1988, 1994, 2001-2015 Free Software Foundation, Inc.
5 ;; Author: Brian Marick
6 ;; Daniel LaLiberte <liberte@holonexus.org>
7 ;; Maintainer: Luke Lee <luke.yx.lee@gmail.com>
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."
145 "Non-nil means don't hide an entire header file enclosed by #ifndef...#endif.
146 Most C/C++ headers are usually wrapped with ifdefs to prevent re-inclusion:
148 ----- beginning of file -----
149 #ifndef _XXX_HEADER_FILE_INCLUDED_
150 #define _XXX_HEADER_FILE_INCLUDED_
151 xxx
152 xxx
153 xxx...
154 #endif
155 ----- end of file -----
157 The first time we visit such a file, _XXX_HEADER_FILE_INCLUDED_ is
158 undefined, and so nothing is hidden. The next time we visit it, everything will
159 be hidden.
161 This behavior is generally undesirable. If this option is non-nil, the outermost
162 #if is always visible."
168 "C/C++ header file name patterns to determine if current buffer is a header.
169 Effective only if `hide-ifdef-expand-reinclusion-protection' is t."
175 ;; Set up the submap that goes after the prefix key.
193 ;; `toggle-read-only' is obsoleted by `read-only-mode'.
196 map)
203 ;; Set up the mode's main map, which leads via the prefix key to the submap.
206 map)
210 "Menu for `hide-ifdef-mode'."
241 minor-mode-alist)))
243 ;; Fix c-mode syntax table so we can recognize whole symbols.
249 st)
256 "This variable is a backup of the previously cleared `hide-ifdef-env'.
257 This backup prevents any accidental clearance of `hide-fidef-env' by
263 ;;;###autoload
265 "Toggle features to hide/show #ifdef blocks (Hide-Ifdef mode).
266 With a prefix argument ARG, enable Hide-Ifdef mode if ARG is
267 positive, and disable it otherwise. If called from Lisp, enable
268 the mode if ARG is omitted or nil.
270 Hide-Ifdef mode is a buffer-local minor mode for use with C and
271 C-like major modes. When enabled, code within #ifdef constructs
272 that the C preprocessor would eliminate may be hidden from view.
273 Several variables affect how the hiding is done:
275 `hide-ifdef-env'
276 An association list of defined and undefined symbols for the
277 current project. Initially, the global value of `hide-ifdef-env'
278 is used. This variable was a buffer-local variable, which limits
279 hideif to parse only one C/C++ file at a time. We've extended
280 hideif to support parsing a C/C++ project containing multiple C/C++
281 source files opened simultaneously in different buffers. Therefore
282 `hide-ifdef-env' can no longer be buffer local but must be global.
284 `hide-ifdef-define-alist'
285 An association list of defined symbol lists.
286 Use `hide-ifdef-set-define-alist' to save the current `hide-ifdef-env'
287 and `hide-ifdef-use-define-alist' to set the current `hide-ifdef-env'
288 from one of the lists in `hide-ifdef-define-alist'.
290 `hide-ifdef-lines'
291 Set to non-nil to not show #if, #ifdef, #ifndef, #else, and
292 #endif lines when hiding.
294 `hide-ifdef-initially'
295 Indicates whether `hide-ifdefs' should be called when Hide-Ifdef mode
296 is activated.
298 `hide-ifdef-read-only'
299 Set to non-nil if you want to make buffers read only while hiding.
300 After `show-ifdefs', read-only status is restored to previous value.
306 ;; inherit global values
308 ;; `hide-ifdef-env' is now a global variable.
309 ;; We can still simulate the behavior of older hideif versions (i.e.
310 ;; `hide-ifdef-env' being buffer local) by clearing this variable
311 ;; (C-c @ C) everytime before hiding current buffer.
312 ;; (set (make-local-variable 'hide-ifdef-env)
313 ;; (default-value 'hide-ifdef-env))
315 ;; Some C/C++ headers might have other ways to prevent reinclusion and
316 ;; thus would like `hide-ifdef-expand-reinclusion-protection' to be nil.
331 ;; else end hide-ifdef-mode
338 "Clears all symbols defined in `hide-ifdef-env'.
339 It will backup this variable to `hide-ifdef-env-backup' before clearing to
340 prevent accidental clearance."
347 "Show all of the text in the current buffer."
351 ;; By putting this on after-revert-hook, we arrange that it only
352 ;; does anything when revert-buffer avoids turning off the mode.
353 ;; (That can happen in VC.)
365 "This function merges nearby ifdef regions to form a bigger overlay.
366 The region is defined by START and END. This will decrease the number of
367 overlays created."
368 ;; Generally there is no need to call itself recursively since there should
369 ;; originally exists no un-merged regions; however, if a part of the file is
370 ;; hidden with `hide-ifdef-lines' equals to nil while another part with 't,
371 ;; this case happens.
372 ;; TODO: Should we merge? or just create a container overlay? -- this can
373 ;; prevent `hideif-show-ifdef' expanding too many hidden contents since there
374 ;; is only a big overlay exists there without any smaller overlays.
377 ; fail to find neighbor overlays
386 b e)
387 ;; Merge overlays before START
395 ;; Merge overlays after END
403 ;; If both START and END merging happens, merge into bigger one
421 "START is the start of a #if, #elif, or #else form. END is the ending part.
422 Everything including these lines is made invisible."
429 "Everything between START and END is made visible."
435 ;;===%%SF%% evaluation (Start) ===
437 ;; It is not useful to set this to anything but `eval'.
438 ;; In fact, the variable might as well be eliminated.
440 "The function to use to evaluate a form.
441 The evaluator is given a canonical form and returns t if text under
449 "Prepend (VAR VALUE) pair to `hide-ifdef-env'."
461 hif-undefined-symbol))))
470 ;;===%%SF%% evaluation (End) ===
474 ;;===%%SF%% parsing (Start) ===
475 ;;; The code that understands what ifs and ifdef in files look like.
486 hif-endif-regexp))
496 "(" hif-white-regexp
500 ")"
503 ;; Store the current token and the whole token list during parsing.
504 ;; Bound dynamically.
517 ;; Note: we include tokens like `=' which aren't supported by CPP's
518 ;; expression syntax, because they are still relevant for the tokenizer,
519 ;; especially in conjunction with ##.
553 "Like `string-to-number', but it understands non-decimal floats."
560 base
564 ;; The dynamic binding variable `hif-simple-token-only' is shared only by
565 ;; `hif-tokenize' and `hif-find-define'. The purpose is to prevent `hif-tokenize'
566 ;; from returning one more value to indicate a simple token is scanned. This help
567 ;; speeding up macro evaluation on those very simple cases like integers or
568 ;; literals.
569 ;; Check the long comments before `hif-find-define' for more details. [lukelee]
573 "Separate string between START and END into a list of tokens."
580 ;; (message "expr-start = %d" expr-start) (sit-for 1)
593 ;; (message "token: %s" token) (sit-for 1)
597 ;; TODO:
598 ;; 1. postfix 'l', 'll', 'ul' and 'ull'
599 ;; 2. floating number formats (like 1.23e4)
600 ;; 3. 098 is interpreted as octal conversion error
602 token)
607 token)
611 token-list)))
619 ;;------------------------------------------------------------------------
620 ;; Translate C preprocessor #if expressions using recursive descent.
621 ;; This parser was limited to the operators &&, ||, !, and "defined".
622 ;; Added ==, !=, +, and -. Gary Oberbrunner, garyo@avs.com, 8/9/94
623 ;;
624 ;; Implement the C language operator precedence table. Add all those
625 ;; missing operators that could be used in macros. Luke Lee 2013-09-04
627 ;; | Operator Type | Operator | Associativity |
628 ;; +----------------------+-----------------------------+---------------+
629 ;; | Primary Expression | () [] . -> expr++ expr-- | left-to-right |
630 ;; | Unary Operators | * & + - ! ~ ++expr --expr | right-to-left |
631 ;; | | (typecast) sizeof | |
632 ;; | Binary Operators | * / % | left-to-right |
633 ;; | | + - | |
634 ;; | | >> << | |
635 ;; | | < > <= >= | |
636 ;; | | == != | |
637 ;; | | & | |
638 ;; | | ^ | |
639 ;; | | | | |
640 ;; | | && | |
641 ;; | | || | |
642 ;; | Ternary Operator | ?: | right-to-left |
643 ;; x| Assignment Operators | = += -= *= /= %= >>= <<= &= | right-to-left |
644 ;; | | ^= = | |
645 ;; | Comma | , | left-to-right |
648 "Pop the next token from token-list into the let variable `hif-token'."
656 "`Upgrade' hif-define xxx to '(hif-define xxx)' so it won't be substituted."
674 tok)
675 result))
679 "Flatten a tree."
686 "Perform expansion on TOKENS till everything expanded.
687 Self-reference (directly or indirectly) tokens are not expanded.
688 EXPAND_LIST is the list of macro names currently being expanded, used for
689 detecting self-reference."
695 tok rep)
698 ;; Expanding all tokens till list exhausted
701 ;; For self-referencing tokens, don't expand it
708 tok)
713 ;; Recursively expand it
716 ;; No argument, no invocation
717 tok
718 ;; Argumented macro, get arguments and invoke it.
719 ;; Dynamically bind hif-token-list and hif-token
720 ;; for hif-macro-supply-arguments
728 tok expand_list)))
730 result))
731 ;; Argument list is nil, direct expansion
734 tok expand_list))
735 ;; Replace all remaining references immediately
737 rep)
738 ;; Lookup tok returns an atom
739 rep))
741 ;;[2013-10-22 16:06:12 +0800] Must keep the token, removing
742 ;; this token might results in an incomplete expression that
743 ;; cannot be parsed further.
744 ;;((= 1 (hif-defined tok)) ; defined (hif-defined tok)=1,
745 ;; ;;but empty (hif-lookup tok)=nil, thus remove this token
746 ;; (setq remains (delete tok remains))
747 ;; nil)
750 tok))
752 expanded))
757 "Parse the TOKEN-LIST.
758 Return translated list in prefix form. MACRONAME is applied when invoking
759 macros to prevent self-reference."
769 "Parse an exprlist: expr { ',' expr}."
779 result)))
782 "Parse an expression as found in #if.
783 expr : or-expr | or-expr '?' expr ':' expr."
785 middle)
794 result))
797 "Parse an or-expr : and-expr | or-expr '||' and-expr."
802 result))
805 "Parse an and-expr : logior-expr | and-expr '&&' logior-expr."
810 result))
813 "Parse a logor-expr : logxor-expr | logor-expr '|' logxor-expr."
818 result))
821 "Parse a logxor-expr : logand-expr | logxor-expr '^' logand-expr."
826 result))
829 "Parse a logand-expr : eq-expr | logand-expr '&' eq-expr."
834 result))
837 "Parse an eq-expr : comp | eq-expr `=='|`!=' comp."
844 result))
847 "Parse a comp-expr : logshift | comp-expr `<'|`>'|`>='|`<=' logshift."
851 hif-less-equal))
855 result))
858 "Parse a logshift : math | logshift `<<'|`>>' math."
865 result))
868 "Parse an expression with + or -.
869 math : muldiv | math '+|-' muldiv."
876 result))
879 "Parse an expression with *,/,%.
880 muldiv : factor | muldiv '*|/|%' factor."
887 result))
890 "Parse a factor.
891 factor : '!' factor | '~' factor | '(' expr ')' | 'defined(' id ')' |
892 'id(parmlist)' | strings | id."
908 result)))
928 ;; Unary plus/minus.
968 "Parse concatenated strings: string | strings string."
974 result))
977 "A marker for defined macro with arguments.
978 This macro cannot be evaluated alone without parameters input."
979 ;;TODO: input arguments at run time, use minibuffer to query all arguments
984 "Stringify a number, string or symbol."
1000 "Concatenate two tokens into a longer token.
1001 Currently support only simple token concatenation. Also support weird (but
1002 valid) token concatenation like '>' ## '>' becomes '>>'. Here we take care only
1003 those that can be evaluated during preprocessing time and ignore all those that
1004 can only be evaluated at C(++) runtime (like '++', '--' and '+='...)."
1012 ;;(error "Invalid token to concatenate")
1014 preprocessing token"
1021 "Treat VAL as a number: if it's t or nil, use 1 or 0."
1074 "Evaluate a list of EXPR, return the result of the last item."
1079 result))
1082 "Scan token list for `hif-stringify' ('#') token and stringify the next token."
1092 result)
1097 "Scan token list for `hif-token-concat' ('##') token and concatenate two tokens."
1099 result)
1114 result)))
1121 ;; Perform token replacement:
1123 "Expand a macro call, replace ACTUAL-PARMS in the macro body."
1131 actual-count
1132 formal-count
1133 formal
1134 etc)
1137 ;; For each actual parameter, evaluate each one and associate it
1138 ;; with an actual parameter, put it into local table and finally
1139 ;; evaluate the macro body.
1141 ;; Take care of `hif-etc' first. Prefix `hif-comma' back if needed.
1152 ;; Perform token replacement on the MACRO-BODY with the parameters
1154 ;; Prevent repetitive substitution, thus cannot use `subst'
1155 ;; for example:
1156 ;; #define mac(a,b) (a+b)
1157 ;; #define testmac mac(b,y)
1158 ;; testmac should expand to (b+y): replace of argument a and b
1159 ;; occurs simultaneously, not sequentially. If sequentially,
1160 ;; according to the argument order, it will become:
1161 ;; 1. formal parm #1 'a' replaced by actual parm 'b', thus (a+b)
1162 ;; becomes (b+b)
1163 ;; 2. formal parm #2 'b' replaced by actual parm 'y', thus (b+b)
1164 ;; becomes (y+y).
1166 ;; Unlike `subst', `substitute' replace only the top level
1167 ;; instead of the whole tree; more importantly, it's not
1168 ;; destructive.
1172 formal macro-body))
1175 ;; Replacement completed, flatten the whole token list
1178 ;; Stringification and token concatenation happens here
1182 "Invoke a macro by expanding it, reparse macro-body and finally invoke it."
1183 ;; Reparse the macro body and evaluate it
1187 macro-name)))
1189 ;;;----------- end of parser -----------------------
1193 "Return the expanded result of the scanned tokens."
1207 tokens)))
1210 "Return a Lisp expression for its condition by scanning current buffer.
1211 Do this when cursor is at the beginning of `regexp' (i.e. #ifX)."
1229 "Move to next #if..., or #ifndef, at point or after."
1230 ;; (message "find ifX at %d" (point))
1237 "Move to next #if..., #elif..., #else, or #endif, after the current line."
1238 ;; (message "hif-find-next-relevant at %d" (point))
1240 ;; Avoid infinite recursion by only going to line-beginning if match found
1245 "Move to previous #if..., #else, or #endif, before the current line."
1246 ;; (message "hif-find-previous-relevant at %d" (point))
1248 ;; Avoid infinite recursion by only going to line-beginning if match found
1265 "If positioned at #ifX, #elif, or #else form, skip to corresponding #endif."
1266 ;; (message "hif-ifdef-to-endif at %d" (point)) (sit-for 1)
1282 "If positioned at #endif form, skip backward to corresponding #ifX."
1283 ;; (message "hif-endif-to-ifdef at %d" (point))
1302 "Move point to beginning of line of the next ifdef-endif.
1303 With argument, do this that many times."
1319 "Move point to beginning of the previous ifdef-endif.
1320 With argument, do this that many times."
1337 "Move point to beginning of nested ifdef or else-part."
1342 ()
1348 "Move point to beginning of enclosing ifdef or else-part."
1360 "Move to the beginning of the next #ifX, #else, or #endif.
1361 With argument, do this that many times."
1373 "Move to the beginning of the previous #ifX, #else, or #endif.
1374 With argument, do this that many times."
1386 ;;===%%SF%% parsing (End) ===
1389 ;;===%%SF%% hide-ifdef-hiding (Start) ===
1392 ;; A range is a structure with four components:
1393 ;; START The start of the range. (beginning of line)
1394 ;; ELSE The else marker (beginning of line)
1395 ;; END The end of the range. (beginning of line)
1396 ;; ELIF A sequence of #elif markers (beginning of line)
1407 ;; Find-Range
1408 ;; The workhorse, it delimits the #if region. Reasonably simple:
1409 ;; Skip until an #else or #endif is found, remembering positions. If
1410 ;; an #else was found, skip some more, looking for the true #endif.
1413 "Return a Range structure describing the current #if region.
1414 Point is left unchanged."
1415 ;; (message "hif-find-range at %d" (point))
1422 ;; Part one. Look for either #elif, #else or #endif.
1423 ;; This loop-and-a-half dedicated to E. Dijkstra.
1429 ;; Found either a #else, #elif, or an #endif.
1436 ;; If found #else, look for #endif.
1448 ;; A bit slimy.
1451 "Hide the line containing point.
1452 Does nothing if `hide-ifdef-lines' is nil."
1460 ;; Hif-Possibly-Hide
1461 ;; There are four cases. The #ifX expression is "taken" if it
1462 ;; the hide-ifdef-evaluator returns T. Presumably, this means the code
1463 ;; inside the #ifdef would be included when the program was
1464 ;; compiled.
1465 ;;
1466 ;; Case 1: #ifX taken, and there's an #else.
1467 ;; The #else part must be hidden. The #if (then) part must be
1468 ;; processed for nested #ifX's.
1469 ;; Case 2: #ifX taken, and there's no #else.
1470 ;; The #if part must be processed for nested #ifX's.
1471 ;; Case 3: #ifX not taken, and there's an #elif
1472 ;; The #if part must be hidden, and then evaluate
1473 ;; the #elif condition like a new #ifX.
1474 ;; Case 4: #ifX not taken, and there's just an #else.
1475 ;; The #if part must be hidden. The #else part must be processed
1476 ;; for nested #ifs.
1477 ;; Case 5: #ifX not taken, and there's no #else.
1478 ;; The #ifX part must be hidden.
1479 ;;
1480 ;; Further processing is done by narrowing to the relevant region
1481 ;; and just recursively calling hide-ifdef-guts.
1482 ;;
1483 ;; When hif-possibly-hide returns, point is at the end of the
1484 ;; possibly-hidden range.
1489 "Call `hide-ifdef-guts' after narrowing to end of START line and END line."
1500 "Called at #ifX expression, this hides those parts that should be hidden.
1501 It uses the judgment of `hide-ifdef-evaluator'. EXPAND-REINCLUSION is a flag
1502 indicating that we should expand the #ifdef even if it should be hidden.
1503 Refer to `hide-ifdef-expand-reinclusion-protection' for more details."
1504 ;; (message "hif-possibly-hide") (sit-for 1)
1511 ;; (message "test = %s" test) (sit-for 1)
1517 ;; ifX/elif is FALSE
1519 ;; Case 3 - Hide the #ifX and eval #elif
1529 ;; Check for #else
1531 ;; Case 4 - #else block visible
1538 ;; Case 5 - No #else block, hide #ifX
1543 ;; ifX/elif is TRUE
1545 ;; Luke fix: distinguish from #elif..#elif to #elif..#else
1547 ;; hide all elifs
1551 elif)))
1553 ;; Case 1 - Hide #elif and #else blocks, recurse #ifX
1560 ;; Case 2 - No #else, just recurse #ifX
1566 ;; complete = t
1573 ; 'do { ... } while (0)'
1579 tokens))))
1581 result))
1584 "Evaluate the macro expansion result for a region.
1585 If no region active, find the current #ifdefs and evaluate the result.
1586 Currently it supports only math calculations, strings or argumented macros can
1587 not be expanded."
1602 ; 'do { ... } while (0)'
1612 nil)))))
1615 ;; Trim off leading/trailing whites
1632 result))))
1635 "Parse argument list formatted as '( arg1 [ , argn] [...] )'.
1636 The '...' is also included. Return a list of the arguments, if '...' exists the
1637 first arg will be `hif-etc'."
1642 etc result token)
1648 t)
1655 ;; The original version of hideif evaluates the macro early and store the
1656 ;; final values for the defined macro into the symbol database (aka
1657 ;; `hide-ifdef-env'). The evaluation process is "strings -> tokens -> parsed
1658 ;; tree -> [value]". (The square bracket refers to what's stored in in our
1659 ;; `hide-ifdef-env'.)
1660 ;;
1661 ;; This forbids the evaluation of an argumented macro since the parameters
1662 ;; are applied at run time. In order to support argumented macro I then
1663 ;; postponed the evaluation process one stage and store the "parsed tree"
1664 ;; into symbol database. The evaluation process was then "strings -> tokens
1665 ;; -> [parsed tree] -> value". Hideif therefore run slower since it need to
1666 ;; evaluate the parsed tree everytime when trying to expand the symbol. These
1667 ;; temporarily code changes are obsolete and not in Emacs source repository.
1668 ;;
1669 ;; Furthermore, CPP did allow partial expression to be defined in several
1670 ;; macros and later got concatenated into a complete expression and then
1671 ;; evaluate it. In order to match this behavior I had to postpone one stage
1672 ;; further, otherwise those partial expression will be fail on parsing and
1673 ;; we'll miss all macros that reference it. The evaluation process thus
1674 ;; became "strings -> [tokens] -> parsed tree -> value." This degraded the
1675 ;; performance since we need to parse tokens and evaluate them everytime
1676 ;; when that symbol is referenced.
1677 ;;
1678 ;; In real cases I found a lot portion of macros are "simple macros" that
1679 ;; expand to literals like integers or other symbols. In order to enhance
1680 ;; the performance I use this `hif-simple-token-only' to notify my code and
1681 ;; save the final [value] into symbol database. [lukelee]
1684 "Parse texts and retrieve all defines within the region MIN and MAX."
1695 ;; Ignore name (still need to return 't), or define the name
1698 name))
1705 ;; `hif-simple-token-only' is set/clear
1706 ;; only in this block
1708 ;; Prevent C statements like
1709 ;; 'do { ... } while (0)'
1712 ;; We can't just return nil here since
1713 ;; this will stop hideif from searching
1714 ;; for more #defines.
1717 start end)))))
1718 ;; For simple tokens we save only the parsed result;
1719 ;; otherwise we save the tokens and parse it after
1720 ;; parameter replacement
1722 ;; `hif-simple-token-only' is checked only
1723 ;; here.
1735 ;; Lazy evaluation, eval only if hif-lookup find it.
1736 ;; Define it anyway, even if nil it's still in list
1737 ;; and therefore considered defined.
1739 ;; #undef
1742 t))
1746 "Scan and add all #define macros between MIN and MAX."
1750 ;; (mark-region min max) ;; for debugging
1757 "Does most of the work of `hide-ifdefs'.
1758 It does not do the work that's pointless to redo on a recursive entry."
1759 ;; (message "hide-ifdef-guts")
1767 min max)
1776 while max))))
1778 ;;===%%SF%% hide-ifdef-hiding (End) ===
1781 ;;===%%SF%% exports (Start) ===
1784 "Toggle `hide-ifdef-read-only'."
1791 hif-outside-read-only)))
1795 "Replacement for `read-only-mode' within Hide-Ifdef mode."
1802 hif-outside-read-only))
1806 "Toggle shadowing."
1822 "Define a VAR to VAL (default 1) in `hide-ifdef-env'.
1823 This allows #ifdef VAR to be hidden."
1831 nil))))
1846 "Undefine a VAR so that #ifdef VAR would not be included."
1861 "Hide the contents of some #ifdefs.
1862 Assume that defined symbols have been added to `hide-ifdef-env'.
1863 The text hidden is the text that would not be included by the C
1864 preprocessor if it were given the file with those symbols defined.
1865 With prefix command presents it will also hide the #ifdefs themselves.
1867 Turn off hiding by calling `show-ifdefs'."
1885 "Cancel the effects of `hide-ifdef': show the contents of all #ifdefs."
1893 "Utility to hide and show ifdef block.
1894 Return as (TOP . BOTTOM) the extent of ifdef block."
1914 "Hide the ifdef block (true or false part) enclosing or before the cursor.
1915 With optional prefix argument ARG, also hide the #ifdefs themselves."
1933 "Show the ifdef block (true or false part) enclosing or before the cursor."
1944 nil)))
1959 del))
1961 ;;(dolist (o (overlays-in (1- (point)) (1+ (point))))
1962 ;; (if (overlay-get o 'hide-ifdef) (message "%S" o)))
1967 ;;; definition alist support
1973 "Compress the define list ENV into a list of defined symbols only."
1979 "Set the association for NAME to `hide-ifdef-env'."
1982 hide-ifdef-define-alist))
1985 "Set `hide-ifdef-env' to the define list specified by NAME."
1989 hide-ifdef-define-alist)
1990 nil t)))
2002 ;;; hideif.el ends here