![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hideif.el CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / lisp|
Return to hideif.el CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / lisp |
1.1 ! root 1: ;;; hide-ifdef-mode.el Hides selected code within ifdef. ! 2: ;;; ! 3: ;;; Copyright (C) 1988 Brian Marick and Daniel LaLiberte ! 4: ;;; Written by Brian Marick, at Gould, Computer Systems Division, Urbana IL. ! 5: ;;; Extensively modified by Daniel LaLiberte (while at Gould). ! 6: ;;; ! 7: ;;; You may freely modify and distribute this, but keep a record ! 8: ;;; of modifications and send comments to: ! 9: ;;; [email protected] or ihnp4!uiucdcs!liberte ! 10: ;;; I will continue to upgrade hide-ifdef-mode ! 11: ;;; with your contributions and will eventually offer it to FSF. ! 12: ;;; ! 13: ;;; $Header: hide-ifdef-mode.el,v 1.7 88/02/16 03:12:58 liberte Exp $ ! 14: ;;; ! 15: ;;; $Log: hide-ifdef-mode.el,v $ ! 16: ;;; Revision 1.7 88/02/16 03:12:58 liberte ! 17: ;;; Fixed comments and doc strings. ! 18: ;;; Added optional prefix arg for ifdef motion commands. ! 19: ;;; ! 20: ;;; Revision 1.6 88/02/05 00:36:18 liberte ! 21: ;;; Bug fixes. ! 22: ;;; 1. A multi-line comment that starts on an #ifdef line ! 23: ;;; now ends on that line. ! 24: ;;; 2. Fix bad function name: hide-hif-ifdef-toggle-read-only ! 25: ;;; 3. Make ifdef-block hiding work outside of ifdefs. ! 26: ;;; ! 27: ;;; Revision 1.5 88/01/31 23:19:31 liberte ! 28: ;;; Major clean up. ! 29: ;;; Prefix internal names with "hif-". ! 30: ;;; ! 31: ;;; Revision 1.4 88/01/30 14:09:38 liberte ! 32: ;;; Add hide-ifdef-hiding and hide-ifdef-mode to minor-mode-alist. ! 33: ;;; ! 34: ;;; Revision 1.3 88/01/29 00:38:19 liberte ! 35: ;;; Fix three bugs. ! 36: ;;; 1. Function "defined" is just like lookup. ! 37: ;;; 2. Skip to newline or cr in case text is hidden. ! 38: ;;; 3. Use car of token list if just one symbol. ! 39: ;;; ! 40: ;;; Revision 1.2 88/01/28 23:32:46 liberte ! 41: ;;; Use hide-ifdef-mode-prefix-key. ! 42: ;;; Copy current-local-map so other buffers do not get ! 43: ;;; hide-ifdef-mode bindings. ! 44: ;;; ! 45: ;;;-------------------------------------------------------------- ! 46: ;;; To initialize, toggle the hide-ifdef minor mode with ! 47: ;;; ! 48: ;;; M-x hide-ifdef-mode ! 49: ;;; ! 50: ;;; This will set up key bindings and call hide-ifdef-mode-hook if it ! 51: ;;; has a value. To explicitly hide ifdefs using a buffer-local ! 52: ;;; define list (default empty), type ! 53: ;;; ! 54: ;;; M-x hide-ifdefs or C-c h ! 55: ;;; ! 56: ;;; Hide-ifdef suppresses the display of code that the preprocessor wouldn't ! 57: ;;; pass through. The support of constant expressions in #if lines is ! 58: ;;; limited to identifiers, parens, and the operators: &&, ||, !, and ! 59: ;;; "defined". Please extend this. ! 60: ;;; ! 61: ;;; The hidden code is marked by ellipses (...). Be ! 62: ;;; cautious when editing near ellipses, since the hidden text is ! 63: ;;; still in the buffer, and you can move the point into it and modify ! 64: ;;; text unawares. If you don't want to see the ellipses, set ! 65: ;;; selective-display-ellipses to nil. But this can be dangerous. ! 66: ;;; You can make your buffer read-only while hide-ifdef-hiding by setting ! 67: ;;; hide-ifdef-read-only to a non-nil value. You can toggle this ! 68: ;;; variable with hide-ifdef-toggle-read-only (C-c C-q). ! 69: ;;; ! 70: ;;; You can undo the effect of hide-ifdefs by typing ! 71: ;;; ! 72: ;;; M-x show-ifdefs or C-c s ! 73: ;;; ! 74: ;;; Use M-x hide-ifdef-define (C-c d) to define a symbol. ! 75: ;;; Use M-x hide-ifdef-undef (C-c u) to undefine a symbol. ! 76: ;;; ! 77: ;;; If you define or undefine a symbol while hide-ifdef-mode is in effect, ! 78: ;;; the display will be updated. Only the define list for the current ! 79: ;;; buffer will be affected. You can save changes to the local define ! 80: ;;; list with hide-ifdef-set-define-alist. This adds entries ! 81: ;;; to hide-ifdef-define-alist. ! 82: ;;; ! 83: ;;; If you have defined a hide-ifdef-mode-hook, you can set ! 84: ;;; up a list of symbols that may be used by hide-ifdefs as in the ! 85: ;;; following example: ! 86: ;;; ! 87: ;;; (setq hide-ifdef-mode-hook ! 88: ;;; '(lambda () ! 89: ;;; (if (not hide-ifdef-define-alist) ! 90: ;;; (setq hide-ifdef-define-alist ! 91: ;;; '((list1 ONE TWO) ! 92: ;;; (list2 TWO THREE) ! 93: ;;; ))) ! 94: ;;; (hide-ifdef-use-define-alist 'list2) ; use list2 by default ! 95: ;;; )) ! 96: ;;; ! 97: ;;; You can call hide-ifdef-use-define-alist (C-c u) at any time to specify ! 98: ;;; another list to use. ! 99: ;;; ! 100: ;;; To cause ifdefs to be hidden as soon as hide-ifdef-mode is called, ! 101: ;;; set hide-ifdef-initially to non-nil. ! 102: ;;; ! 103: ;;; If you set hide-ifdef-lines to t, hide-ifdefs hides all the #ifdef lines. ! 104: ;;; In the absence of highlighting, that might be a bad idea. If you set ! 105: ;;; hide-ifdef-lines to nil (the default), the surrounding preprocessor ! 106: ;;; lines will be displayed. That can be confusing in its own ! 107: ;;; right. Other variations on display are possible, but not much ! 108: ;;; better. ! 109: ;;; ! 110: ;;; You can explicitly hide or show individual ifdef blocks irrespective ! 111: ;;; of the define list by using hide-ifdef-block and show-ifdef-block. ! 112: ;;; ! 113: ;;; You can move the point between ifdefs with forward-ifdef, backward-ifdef, ! 114: ;;; up-ifdef, down-ifdef, next-ifdef, and previous-ifdef. ! 115: ;;; ! 116: ;;; If you have minor-mode-alist in your mode line (the default) two labels ! 117: ;;; may appear. "Ifdef" will appear when hide-ifdef-mode is active. "Hiding" ! 118: ;;; will appear when text may be hidden ("hide-ifdef-hiding" is non-nil). ! 119: ! 120: ! 121: ! 122: (defvar hide-ifdef-mode-map nil ! 123: "Keymap used with hide-ifdef mode") ! 124: ! 125: (defconst hide-ifdef-mode-prefix-key "\C-c" ! 126: "Prefix key for all hide-ifdef-mode commands.") ! 127: ! 128: (defvar hide-ifdef-mode-map-before nil ! 129: "Buffer-local variable to store a copy of the local keymap ! 130: before hide-ifdef-mode modifies it.") ! 131: ! 132: (defun define-hide-ifdef-mode-map () ! 133: (if hide-ifdef-mode-map ! 134: () ; dont redefine it. ! 135: (setq hide-ifdef-mode-map (make-sparse-keymap)) ! 136: (define-key hide-ifdef-mode-map "d" 'hide-ifdef-define) ! 137: (define-key hide-ifdef-mode-map "u" 'hide-ifdef-undef) ! 138: (define-key hide-ifdef-mode-map "D" 'hide-ifdef-set-define-alist) ! 139: (define-key hide-ifdef-mode-map "U" 'hide-ifdef-use-define-alist) ! 140: ! 141: (define-key hide-ifdef-mode-map "h" 'hide-ifdefs) ! 142: (define-key hide-ifdef-mode-map "s" 'show-ifdefs) ! 143: (define-key hide-ifdef-mode-map "\C-h" 'hide-ifdef-block) ! 144: (define-key hide-ifdef-mode-map "\C-s" 'show-ifdef-block) ! 145: ! 146: (define-key hide-ifdef-mode-map "\C-f" 'forward-ifdef) ! 147: (define-key hide-ifdef-mode-map "\C-b" 'backward-ifdef) ! 148: (define-key hide-ifdef-mode-map "\C-d" 'down-ifdef) ! 149: (define-key hide-ifdef-mode-map "\C-u" 'up-ifdef) ! 150: (define-key hide-ifdef-mode-map "\C-n" 'next-ifdef) ! 151: (define-key hide-ifdef-mode-map "\C-p" 'previous-ifdef) ! 152: (define-key hide-ifdef-mode-map "\C-q" 'hide-ifdef-toggle-read-only) ! 153: (define-key hide-ifdef-mode-map ! 154: (where-is-internal 'toggle-read-only nil t) ! 155: 'hide-ifdef-toggle-outside-read-only) ! 156: ) ! 157: (fset 'hide-ifdef-mode-map hide-ifdef-mode-map) ; the function is the map ! 158: ) ! 159: ! 160: (defun hif-update-mode-line () ! 161: "Update mode-line by setting buffer-modified to itself." ! 162: (set-buffer-modified-p (buffer-modified-p))) ! 163: ! 164: ! 165: (defvar hide-ifdef-mode nil ! 166: "non-nil when hide-ifdef-mode is activated.") ! 167: ! 168: (defvar hide-ifdef-hiding nil ! 169: "non-nil when text may be hidden.") ! 170: ! 171: (or (assq 'hide-ifdef-hiding minor-mode-alist) ! 172: (setq minor-mode-alist ! 173: (cons '(hide-ifdef-hiding " Hiding") ! 174: minor-mode-alist))) ! 175: ! 176: (or (assq 'hide-ifdef-mode minor-mode-alist) ! 177: (setq minor-mode-alist ! 178: (cons '(hide-ifdef-mode " Ifdef") ! 179: minor-mode-alist))) ! 180: ! 181: ! 182: (defun hide-ifdef-mode (arg) ! 183: "Toggle hide-ifdef-mode. Thus this is a minor mode, albeit a large one. ! 184: With arg, turn hide-ifdef-mode on iff arg is positive. ! 185: In hide-ifdef-mode, code within #ifdef constructs that the C preprocessor ! 186: would eliminate may be hidden from view. Several variables affect ! 187: how the hiding is done: ! 188: ! 189: hide-ifdef-env ! 190: An association list of defined and undefined symbols for the ! 191: current buffer. Initially, the global value of hide-ifdef-env is used. ! 192: ! 193: hide-ifdef-define-alist ! 194: An association list of defined symbol lists. ! 195: Use hide-ifdef-set-define-alist to save the current hide-ifdef-env ! 196: and hide-ifdef-use-define-alist to set the current hide-ifdef-env ! 197: from one of the lists in hide-ifdef-define-alist. ! 198: ! 199: hide-ifdef-lines ! 200: Set to non-nil to not show #if, #ifdef, #ifndef, #else, and ! 201: #endif lines when hiding. ! 202: ! 203: hide-ifdef-initially ! 204: Indicates whether hide-ifdefs should be called when hide-ifdef-mode ! 205: is activated. ! 206: ! 207: hide-ifdef-read-only ! 208: Set to non-nil if you want to make buffers read only while hiding. ! 209: After show-ifdefs, read-only status is restored to previous value. ! 210: ! 211: \\{hide-ifdef-mode-map}" ! 212: ! 213: (interactive "P") ! 214: (make-local-variable 'hide-ifdef-mode) ! 215: (setq hide-ifdef-mode ! 216: (if (null arg) ! 217: (not hide-ifdef-mode) ! 218: (> (prefix-numeric-value arg) 0))) ! 219: ! 220: (hif-update-mode-line) ! 221: ! 222: (if hide-ifdef-mode ! 223: (progn ! 224: ; fix c-mode syntax table so we can recognize whole symbols. ! 225: (modify-syntax-entry ?_ "w") ! 226: (modify-syntax-entry ?& ".") ! 227: (modify-syntax-entry ?\| ".") ! 228: ! 229: ; inherit global values ! 230: (make-local-variable 'hide-ifdef-env) ! 231: (setq hide-ifdef-env (default-value 'hide-ifdef-env)) ! 232: ! 233: (make-local-variable 'hide-ifdef-hiding) ! 234: (setq hide-ifdef-hiding (default-value 'hide-ifdef-hiding)) ! 235: ! 236: (make-local-variable 'hif-outside-read-only) ! 237: (setq hif-outside-read-only buffer-read-only) ! 238: ! 239: (make-local-variable 'ide-ifdef-mode-map-before) ! 240: (setq hide-ifdef-mode-map-before (current-local-map)) ! 241: (use-local-map (copy-keymap (current-local-map))) ! 242: (local-unset-key hide-ifdef-mode-prefix-key) ! 243: (local-set-key hide-ifdef-mode-prefix-key 'hide-ifdef-mode-map) ! 244: (define-hide-ifdef-mode-map) ! 245: ! 246: (run-hooks 'hide-ifdef-mode-hook) ! 247: ! 248: (if hide-ifdef-initially ! 249: (hide-ifdefs) ! 250: (show-ifdefs)) ! 251: (message "Enter hide-ifdef-mode.") ! 252: ) ! 253: ; else end hide-ifdef-mode ! 254: (if hide-ifdef-hiding ! 255: (show-ifdefs)) ! 256: (use-local-map hide-ifdef-mode-map-before) ! 257: (message "Exit hide-ifdef-mode.") ! 258: )) ! 259: ! 260: ! 261: ;; from outline.el with docstring fixed. ! 262: (defun hif-outline-flag-region (from to flag) ! 263: "Hides or shows lines from FROM to TO, according to FLAG. If FLAG ! 264: is \\n (newline character) then text is shown, while if FLAG is \\^M ! 265: \(control-M) the text is hidden." ! 266: (let ((modp (buffer-modified-p))) ! 267: (unwind-protect (progn ! 268: (subst-char-in-region from to ! 269: (if (= flag ?\n) ?\^M ?\n) ! 270: flag t) ) ! 271: (set-buffer-modified-p modp)) ! 272: )) ! 273: ! 274: (defun hif-show-all () ! 275: "Show all of the text in the current buffer." ! 276: (interactive) ! 277: (hif-outline-flag-region (point-min) (point-max) ?\n)) ! 278: ! 279: (defun hide-ifdef-region (start end) ! 280: "START is the start of a #if or #else form. END is the ending part. ! 281: Everything including these lines is made invisible." ! 282: (hif-outline-flag-region start end ?\^M) ! 283: ) ! 284: ! 285: (defun hif-show-ifdef-region (start end) ! 286: "Everything between START and END is made visible." ! 287: (hif-outline-flag-region start end ?\n) ! 288: ) ! 289: ! 290: ! 291: ! 292: ;===%%SF%% evaluation (Start) === ! 293: ! 294: (defvar hide-ifdef-evaluator 'eval ! 295: "The evaluator is given a canonical form and returns T if text under ! 296: that form should be displayed.") ! 297: ! 298: (defvar hif-undefined-symbol nil ! 299: "...is by default considered to be false.") ! 300: ! 301: (defvar hide-ifdef-env nil ! 302: "An alist of defined symbols and their values.") ! 303: ! 304: ! 305: (defun hif-set-var (var value) ! 306: "Prepend (var value) pair to hide-ifdef-env." ! 307: (setq hide-ifdef-env (cons (cons var value) hide-ifdef-env))) ! 308: ! 309: ! 310: (defun hif-lookup (var) ! 311: ; (message "hif-lookup %s" var) ! 312: (let ((val (assoc var hide-ifdef-env))) ! 313: (if val ! 314: (cdr val) ! 315: hif-undefined-symbol))) ! 316: ! 317: (defun hif-defined (var) ! 318: (hif-lookup var) ! 319: ; when #if expressions are fully supported, defined result should be 1 ! 320: ; (if (assoc var hide-ifdef-env) ! 321: ; 1 ! 322: ; nil) ! 323: ) ! 324: ! 325: ! 326: ;===%%SF%% evaluation (End) === ! 327: ! 328: ! 329: ! 330: ;===%%SF%% parsing (Start) === ! 331: ;;; The code that understands what ifs and ifdef in files look like. ! 332: ! 333: (defconst hif-cpp-prefix "\\(^\\|\r\\)[ \t]*#[ \t]*") ! 334: (defconst hif-ifndef-regexp (concat hif-cpp-prefix "ifndef")) ! 335: (defconst hif-ifx-regexp (concat hif-cpp-prefix "if\\(n?def\\)?[ \t]+")) ! 336: (defconst hif-else-regexp (concat hif-cpp-prefix "else")) ! 337: (defconst hif-endif-regexp (concat hif-cpp-prefix "endif")) ! 338: (defconst hif-ifx-else-endif-regexp ! 339: (concat hif-ifx-regexp "\\|" hif-else-regexp "\\|" hif-endif-regexp)) ! 340: ! 341: ! 342: (defun hif-infix-to-prefix (token-list) ! 343: "Convert list of tokens in infix into prefix list" ! 344: ; (message "hif-infix-to-prefix: %s" token-list) ! 345: (if (= 1 (length token-list)) ! 346: (` (hif-lookup (quote (, (car token-list))))) ! 347: (hif-parse-if-exp token-list)) ! 348: ) ! 349: ! 350: ; pattern to match initial identifier, !, &&, ||, (, or ). ! 351: (defconst hif-token-regexp "^\\(!\\|&&\\|||\\|[()]\\|\\w+\\)") ! 352: (defconst hif-end-of-comment "\\*/") ! 353: ! 354: ! 355: (defun hif-tokenize (expr-string) ! 356: "Separate string into a list of tokens" ! 357: (let ((token-list nil) ! 358: (expr-start 0) ! 359: (expr-length (length expr-string))) ! 360: ! 361: (while (< expr-start expr-length) ! 362: ; (message "expr-start = %d" expr-start) (sit-for 1) ! 363: (cond ! 364: ((string-match "^[ \t]+" expr-string expr-start) ! 365: ; skip whitespace ! 366: (setq expr-start (match-end 0)) ! 367: ; stick newline in string so ^ matches on the next string-match ! 368: (aset expr-string (1- expr-start) ?\n) ! 369: ) ! 370: ! 371: ((string-match "^/\\*" expr-string expr-start) ! 372: (setq expr-start (match-end 0)) ! 373: (aset expr-string (1- expr-start) ?\n) ! 374: (or ! 375: (string-match hif-end-of-comment ! 376: expr-string expr-start) ; eat comment ! 377: (string-match "$" expr-string expr-start)) ; multi-line comment ! 378: (setq expr-start (match-end 0)) ! 379: (aset expr-string (1- expr-start) ?\n) ! 380: ) ! 381: ! 382: ((string-match hif-token-regexp expr-string expr-start) ! 383: (let ((token (substring expr-string expr-start (match-end 0)))) ! 384: (setq expr-start (match-end 0)) ! 385: (aset expr-string (1- expr-start) ?\n) ! 386: ; (message "token: %s" token) (sit-for 1) ! 387: (setq token-list ! 388: (cons ! 389: (cond ! 390: ((string-equal token "||") 'or) ! 391: ((string-equal token "&&") 'and) ! 392: ((string-equal token "!") 'not) ! 393: ((string-equal token "defined") 'hif-defined) ! 394: ((string-equal token "(") 'lparen) ! 395: ((string-equal token ")") 'rparen) ! 396: (t (intern token))) ! 397: token-list)) ! 398: )) ! 399: (t (error "Bad #if expression: %s" expr-string)) ! 400: )) ! 401: (nreverse token-list) ! 402: )) ! 403: ! 404: ;;;----------------------------------------------------------------- ! 405: ;;; Translate C preprocessor #if expressions using recursive descent. ! 406: ;;; This parser is limited to the operators &&, ||, !, and "defined". ! 407: ! 408: (defun hif-parse-if-exp (token-list) ! 409: "Parse the TOKEN-LIST. Return translated list in prefix form." ! 410: (hif-nexttoken) ! 411: (prog1 ! 412: (hif-expr) ! 413: (if token ; is there still a token? ! 414: (error "Error: unexpected token: %s" token))) ! 415: ) ! 416: ! 417: (defun hif-nexttoken () ! 418: "Pop the next token from token-list into the let variable \"token\"." ! 419: (setq token (car token-list)) ! 420: (setq token-list (cdr token-list)) ! 421: token ! 422: ) ! 423: ! 424: (defun hif-expr () ! 425: "Parse and expression of the form ! 426: expr : term | expr '||' term." ! 427: (let ((result (hif-term))) ! 428: (while (eq token 'or) ! 429: (hif-nexttoken) ! 430: (setq result (list 'or result (hif-term)))) ! 431: result ! 432: )) ! 433: ! 434: (defun hif-term () ! 435: "Parse a term of the form ! 436: term : factor | term '&&' factor." ! 437: (let ((result (hif-factor))) ! 438: (while (eq token 'and) ! 439: (hif-nexttoken) ! 440: (setq result (list 'and result (hif-factor)))) ! 441: result ! 442: )) ! 443: ! 444: (defun hif-factor () ! 445: "Parse a factor of the form ! 446: factor : '!' factor | '(' expr ')' | 'defined(' id ')' | id." ! 447: (cond ! 448: ((eq token 'not) ! 449: (hif-nexttoken) ! 450: (list 'not (hif-factor))) ! 451: ! 452: ((eq token 'lparen) ! 453: (hif-nexttoken) ! 454: (let ((result (hif-expr))) ! 455: (if (not (eq token 'rparen)) ! 456: (error "Bad token in parenthesized expression: %s" token) ! 457: (hif-nexttoken) ! 458: result))) ! 459: ! 460: ((eq token 'hif-defined) ! 461: (hif-nexttoken) ! 462: (if (not (eq token 'lparen)) ! 463: (error "Error: expected \"(\" after \"define\"")) ! 464: (hif-nexttoken) ! 465: (let ((ident token)) ! 466: (if (memq token '(or and not hif-defined lparen rparen)) ! 467: (error "Error: unexpected token: %s" token)) ! 468: (hif-nexttoken) ! 469: (if (not (eq token 'rparen)) ! 470: (error "Error: expected \")\" after identifier")) ! 471: (hif-nexttoken) ! 472: (` (hif-defined (quote (, ident)))) ! 473: )) ! 474: ! 475: (t ; identifier ! 476: (let ((ident token)) ! 477: (if (memq ident '(or and)) ! 478: (error "Error: missing identifier")) ! 479: (hif-nexttoken) ! 480: (` (hif-lookup (quote (, ident)))) ! 481: )) ! 482: ! 483: )) ! 484: ! 485: ;;;----------- end of parser ----------------------- ! 486: ! 487: ! 488: (defun hif-canonicalize () ! 489: "When at beginning of #ifX, returns a canonical (evaluatable) ! 490: form for the expression." ! 491: (save-excursion ! 492: (let ((negate (looking-at hif-ifndef-regexp))) ! 493: (re-search-forward hif-ifx-regexp) ! 494: (let* ((expr-string ! 495: (buffer-substring (point) ! 496: (progn (skip-chars-forward "^\n\r") (point)))) ! 497: (expr (hif-infix-to-prefix (hif-tokenize expr-string)))) ! 498: ; (message "hif-canonicalized: %s" expr) ! 499: (if negate ! 500: (list 'not expr) ! 501: expr))))) ! 502: ! 503: ! 504: (defun hif-find-any-ifX () ! 505: "Position at beginning of next #if, #ifdef, or #ifndef, including one on ! 506: this line." ! 507: ; (message "find ifX at %d" (point)) ! 508: (prog1 ! 509: (re-search-forward hif-ifx-regexp (point-max) t) ! 510: (beginning-of-line))) ! 511: ! 512: ! 513: (defun hif-find-next-relevant () ! 514: "Position at beginning of next #ifdef, #ifndef, #else, #endif, ! 515: NOT including one on this line." ! 516: ; (message "hif-find-next-relevant at %d" (point)) ! 517: (end-of-line) ! 518: ; avoid infinite recursion by only going to beginning of line if match found ! 519: (if (re-search-forward hif-ifx-else-endif-regexp (point-max) t) ! 520: (beginning-of-line)) ! 521: ) ! 522: ! 523: (defun hif-find-previous-relevant () ! 524: "Position at beginning of previous #ifdef, #ifndef, #else, #endif, ! 525: NOT including one on this line." ! 526: ; (message "hif-find-previous-relevant at %d" (point)) ! 527: (beginning-of-line) ! 528: ; avoid infinite recursion by only going to beginning of line if match found ! 529: (if (re-search-backward hif-ifx-else-endif-regexp (point-min) t) ! 530: (beginning-of-line) ! 531: ) ! 532: ) ! 533: ! 534: ! 535: (defun hif-looking-at-ifX () ;; Should eventually see #if ! 536: (looking-at hif-ifx-regexp)) ! 537: (defun hif-looking-at-endif () ! 538: (looking-at hif-endif-regexp)) ! 539: (defun hif-looking-at-else () ! 540: (looking-at hif-else-regexp)) ! 541: ! 542: ! 543: ! 544: (defun hif-ifdef-to-endif () ! 545: "If positioned at #ifX or #else form, skip to corresponding #endif." ! 546: ; (message "hif-ifdef-to-endif at %d" (point)) (sit-for 1) ! 547: (hif-find-next-relevant) ! 548: (cond ((hif-looking-at-ifX) ! 549: (hif-ifdef-to-endif) ; find endif of nested if ! 550: (hif-ifdef-to-endif)) ; find outer endif or else ! 551: ((hif-looking-at-else) ! 552: (hif-ifdef-to-endif)) ; find endif following else ! 553: ((hif-looking-at-endif) ! 554: 'done) ! 555: (t ! 556: (error "Missmatched #ifdef #endif pair")) ! 557: )) ! 558: ! 559: ! 560: (defun hif-endif-to-ifdef () ! 561: "If positioned at #endif form, skip backward to corresponding #ifX." ! 562: ; (message "hif-endif-to-ifdef at %d" (point)) ! 563: (let ((start (point))) ! 564: (hif-find-previous-relevant) ! 565: (if (= start (point)) ! 566: (error "Missmatched #ifdef #endif pair"))) ! 567: (cond ((hif-looking-at-endif) ! 568: (hif-endif-to-ifdef) ; find beginning of nested if ! 569: (hif-endif-to-ifdef)) ; find beginning of outer if or else ! 570: ((hif-looking-at-else) ! 571: (hif-endif-to-ifdef)) ! 572: ((hif-looking-at-ifX) ! 573: 'done) ! 574: (t ; never gets here ! 575: ))) ! 576: ! 577: ! 578: (defun forward-ifdef (&optional arg) ! 579: "Move point to beginning of line of the next ifdef-endif. ! 580: With argument, do this that many times." ! 581: (interactive "p") ! 582: (or arg (setq arg 1)) ! 583: (if (< arg 0) ! 584: (backward-ifdef (- arg))) ! 585: (while (< 0 arg) ! 586: (setq arg (- arg)) ! 587: (let ((start (point))) ! 588: (if (not (hif-looking-at-ifX)) ! 589: (hif-find-next-relevant)) ! 590: (if (hif-looking-at-ifX) ! 591: (hif-ifdef-to-endif) ! 592: (goto-char start) ! 593: (error "No following #ifdef") ! 594: )))) ! 595: ! 596: ! 597: (defun backward-ifdef (&optional arg) ! 598: "Move point to beginning of the previous ifdef-endif. ! 599: With argument, do this that many times." ! 600: (interactive "p") ! 601: (or arg (setq arg 1)) ! 602: (if (< arg 0) ! 603: (forward-ifdef (- arg))) ! 604: (while (< 0 arg) ! 605: (setq arg (1- arg)) ! 606: (beginning-of-line) ! 607: (let ((start (point))) ! 608: (if (not (hif-looking-at-endif)) ! 609: (hif-find-previous-relevant)) ! 610: (if (hif-looking-at-endif) ! 611: (hif-endif-to-ifdef) ! 612: (goto-char start) ! 613: (error "No previous #ifdef") ! 614: )))) ! 615: ! 616: ! 617: ! 618: (defun down-ifdef () ! 619: "Move point to beginning of nested ifdef or else-part." ! 620: (interactive) ! 621: (let ((start (point))) ! 622: (hif-find-next-relevant) ! 623: (if (or (hif-looking-at-ifX) (hif-looking-at-else)) ! 624: () ! 625: (goto-char start) ! 626: (error "No following #ifdef") ! 627: ))) ! 628: ! 629: ! 630: (defun up-ifdef () ! 631: "Move point to beginning of enclosing ifdef or else-part." ! 632: (interactive) ! 633: (beginning-of-line) ! 634: (let ((start (point))) ! 635: (if (not (hif-looking-at-endif)) ! 636: (hif-find-previous-relevant)) ! 637: (if (hif-looking-at-endif) ! 638: (hif-endif-to-ifdef)) ! 639: (if (= start (point)) ! 640: (error "No previous #ifdef") ! 641: ))) ! 642: ! 643: (defun next-ifdef (&optional arg) ! 644: "Move to the beginning of the next #ifX, #else, or #endif. ! 645: With argument, do this that many times." ! 646: (interactive "p") ! 647: (or arg (setq arg 1)) ! 648: (if (< arg 0) ! 649: (previous-ifdef (- arg))) ! 650: (while (< 0 arg) ! 651: (setq arg (1- arg)) ! 652: (hif-find-next-relevant) ! 653: (if (eolp) ! 654: (progn ! 655: (beginning-of-line) ! 656: (error "No following #ifdefs, #elses, or #endifs") ! 657: )))) ! 658: ! 659: (defun previous-ifdef (&optional arg) ! 660: "Move to the beginning of the previous #ifX, #else, or #endif. ! 661: With argument, do this that many times." ! 662: (interactive "p") ! 663: (or arg (setq arg 1)) ! 664: (if (< arg 0) ! 665: (next-ifdef (- arg))) ! 666: (while (< 0 arg) ! 667: (setq arg (1- arg)) ! 668: (let ((start (point))) ! 669: (hif-find-previous-relevant) ! 670: (if (= start (point)) ! 671: (error "No previous #ifdefs, #elses, or #endifs") ! 672: )))) ! 673: ! 674: ! 675: ;===%%SF%% parsing (End) === ! 676: ! 677: ! 678: ;===%%SF%% hide-ifdef-hiding (Start) === ! 679: ! 680: ! 681: ;;; A range is a structure with four components: ! 682: ;;; ELSE-P True if there was an else clause for the ifdef. ! 683: ;;; START The start of the range. (beginning of line) ! 684: ;;; ELSE The else marker (beginning of line) ! 685: ;;; Only valid if ELSE-P is true. ! 686: ;;; END The end of the range. (beginning of line) ! 687: ! 688: (defun hif-make-range (else-p start end &optional else) ! 689: (list else-p start else end)) ! 690: ! 691: (defun hif-range-else-p (range) (elt range 0)) ! 692: (defun hif-range-start (range) (elt range 1)) ! 693: (defun hif-range-else (range) (elt range 2)) ! 694: (defun hif-range-end (range) (elt range 3)) ! 695: ! 696: ! 697: ! 698: ;;; Find-Range ! 699: ;;; The workhorse, it delimits the #if region. Reasonably simple: ! 700: ;;; Skip until an #else or #endif is found, remembering positions. If ! 701: ;;; an #else was found, skip some more, looking for the true #endif. ! 702: ! 703: (defun hif-find-range () ! 704: "Returns a Range structure describing the current #if region. ! 705: Point is left unchanged." ! 706: ; (message "hif-find-range at %d" (point)) ! 707: (save-excursion ! 708: (beginning-of-line) ! 709: (let ((start (point)) ! 710: (else-p nil) ! 711: (else nil) ! 712: (end nil)) ! 713: ;; Part one. Look for either #endif or #else. ! 714: ;; This loop-and-a-half dedicated to E. Dijkstra. ! 715: (hif-find-next-relevant) ! 716: (while (hif-looking-at-ifX) ; Skip nested ifdef ! 717: (hif-ifdef-to-endif) ! 718: (hif-find-next-relevant)) ! 719: ;; Found either a #else or an #endif. ! 720: (cond ((hif-looking-at-else) ! 721: (setq else-p t) ! 722: (setq else (point))) ! 723: (t ! 724: (setq end (point)) ; (save-excursion (end-of-line) (point)) ! 725: )) ! 726: ;; If found #else, look for #endif. ! 727: (if else-p ! 728: (progn ! 729: (hif-find-next-relevant) ! 730: (while (hif-looking-at-ifX) ; Skip nested ifdef ! 731: (hif-ifdef-to-endif) ! 732: (hif-find-next-relevant)) ! 733: (if (hif-looking-at-else) ! 734: (error "Found two elses in a row? Broken!")) ! 735: (setq end (point)) ; (save-excursion (end-of-line) (point)) ! 736: )) ! 737: (hif-make-range else-p start end else)))) ! 738: ! 739: ! 740: ;;; A bit slimy. ! 741: ;;; NOTE: If there's an #ifdef at the beginning of the file, we can't ! 742: ;;; hide it. There's no previous newline to replace. If we added ! 743: ;;; one, we'd throw off all the counts. Feh. ! 744: ! 745: (defun hif-hide-line (point) ! 746: "Hide the line containing point. Does nothing if ! 747: hide-ifdef-lines is nil." ! 748: (if hide-ifdef-lines ! 749: (save-excursion ! 750: (goto-char point) ! 751: (let ((modp (buffer-modified-p))) ! 752: (unwind-protect ! 753: (progn ! 754: (beginning-of-line) ! 755: (if (not (= (point) 1)) ! 756: (hide-ifdef-region (1- (point)) (point)))) ! 757: (set-buffer-modified-p modp)) ! 758: )) ! 759: )) ! 760: ! 761: ! 762: ;;; Hif-Possibly-Hide ! 763: ;;; There are four cases. The #ifX expression is "taken" if it ! 764: ;;; the hide-ifdef-evaluator returns T. Presumably, this means the code ! 765: ;;; inside the #ifdef would be included when the program was ! 766: ;;; compiled. ! 767: ;;; ! 768: ;;; Case 1: #ifX taken, and there's an #else. ! 769: ;;; The #else part must be hidden. The #if (then) part must be ! 770: ;;; processed for nested #ifX's. ! 771: ;;; Case 2: #ifX taken, and there's no #else. ! 772: ;;; The #if part must be processed for nested #ifX's. ! 773: ;;; Case 3: #ifX not taken, and there's an #else. ! 774: ;;; The #if part must be hidden. The #else part must be processed ! 775: ;;; for nested #ifs. ! 776: ;;; Case 4: #ifX not taken, and there's no #else. ! 777: ;;; The #ifX part must be hidden. ! 778: ;;; ! 779: ;;; Further processing is done by narrowing to the relevant region ! 780: ;;; and just recursively calling hide-ifdef-guts. ! 781: ;;; ! 782: ;;; When hif-possibly-hide returns, point is at the end of the ! 783: ;;; possibly-hidden range. ! 784: ! 785: (defun hif-recurse-on (start end) ! 786: "Call hide-ifdef-guts after narrowing to end of START line and END ! 787: line." ! 788: (save-excursion ! 789: (save-restriction ! 790: (goto-char start) ! 791: (end-of-line) ! 792: (narrow-to-region (point) end) ! 793: (hide-ifdef-guts)))) ! 794: ! 795: (defun hif-possibly-hide () ! 796: "Called at #ifX expression, this hides those parts that should be ! 797: hidden, according to judgement of hide-ifdef-evaluator." ! 798: ; (message "hif-possibly-hide") (sit-for 1) ! 799: (let ((test (hif-canonicalize)) ! 800: (range (hif-find-range))) ! 801: ; (message "test = %s" test) (sit-for 1) ! 802: ! 803: (hif-hide-line (hif-range-end range)) ! 804: (if (funcall hide-ifdef-evaluator test) ! 805: (cond ((hif-range-else-p range) ; case 1 ! 806: (hif-hide-line (hif-range-else range)) ! 807: (hide-ifdef-region (hif-range-else range) ! 808: (1- (hif-range-end range))) ! 809: (hif-recurse-on (hif-range-start range) ! 810: (hif-range-else range))) ! 811: (t ; case 2 ! 812: (hif-recurse-on (hif-range-start range) ! 813: (hif-range-end range)))) ! 814: (cond ((hif-range-else-p range) ; case 3 ! 815: (hif-hide-line (hif-range-else range)) ! 816: (hide-ifdef-region (hif-range-start range) ! 817: (1- (hif-range-else range))) ! 818: (hif-recurse-on (hif-range-else range) ! 819: (hif-range-end range))) ! 820: (t ; case 4 ! 821: (hide-ifdef-region (point) ! 822: (1- (hif-range-end range)))) ! 823: )) ! 824: (hif-hide-line (hif-range-start range)) ; Always hide start. ! 825: (goto-char (hif-range-end range)) ! 826: (end-of-line) ! 827: )) ! 828: ! 829: ! 830: ! 831: (defun hide-ifdef-guts () ! 832: "Does the work of hide-ifdefs, except for the work that's pointless ! 833: to redo on a recursive entry." ! 834: ; (message "hide-ifdef-guts") ! 835: (save-excursion ! 836: (goto-char (point-min)) ! 837: (while (hif-find-any-ifX) ! 838: (hif-possibly-hide)))) ! 839: ! 840: ;===%%SF%% hide-ifdef-hiding (End) === ! 841: ! 842: ! 843: ;===%%SF%% exports (Start) === ! 844: ! 845: (defvar hide-ifdef-initially nil ! 846: "*Non-nil if hide-ifdefs should be called when hide-ifdef-mode ! 847: is first activated.") ! 848: ! 849: (defvar hide-ifdef-hiding nil ! 850: "Non-nil if text might be hidden.") ! 851: ! 852: (defvar hide-ifdef-read-only nil ! 853: "*Set to non-nil if you want buffer to be read-only while hiding text.") ! 854: ! 855: (defvar hif-outside-read-only nil ! 856: "Internal variable. Saves the value of buffer-read-only while hiding.") ! 857: ! 858: (defvar hide-ifdef-lines nil ! 859: "*Set to t if you don't want to see the #ifX, #else, and #endif lines.") ! 860: ! 861: (defun hide-ifdef-toggle-read-only () ! 862: "Toggle hide-ifdef-read-only." ! 863: (interactive) ! 864: (setq hide-ifdef-read-only (not hide-ifdef-read-only)) ! 865: (message "Hide-Read-Only %s" ! 866: (if hide-ifdef-read-only "ON" "OFF")) ! 867: (if hide-ifdef-hiding ! 868: (setq buffer-read-only (or hide-ifdef-read-only hif-outside-read-only))) ! 869: (hif-update-mode-line) ! 870: ) ! 871: ! 872: (defun hide-ifdef-toggle-outside-read-only () ! 873: "Replacement for toggle-read-only within hide-ifdef-mode." ! 874: (interactive) ! 875: (setq hif-outside-read-only (not hif-outside-read-only)) ! 876: (message "Read only %s" ! 877: (if hif-outside-read-only "ON" "OFF")) ! 878: (setq buffer-read-only ! 879: (or (and hide-ifdef-hiding hide-ifdef-read-only) ! 880: hif-outside-read-only) ! 881: ) ! 882: (hif-update-mode-line) ! 883: ) ! 884: ! 885: ! 886: (defun hide-ifdef-define (var) ! 887: "Define a VAR so that #ifdef VAR would be included." ! 888: (interactive "SDefine what? ") ! 889: (hif-set-var var t) ! 890: (if hide-ifdef-hiding (hide-ifdefs))) ! 891: ! 892: (defun hide-ifdef-undef (var) ! 893: "Undefine a VAR so that #ifdef VAR would not be included." ! 894: (interactive "SUndefine what? ") ! 895: (hif-set-var var nil) ! 896: (if hide-ifdef-hiding (hide-ifdefs))) ! 897: ! 898: ! 899: (defun hide-ifdefs () ! 900: "Hide the contents of some #ifdefs. Assume that defined symbols have ! 901: been added to hide-ifdef-env. The text hidden is the text that would not ! 902: be included by the C preprocessor if it were given the file with those ! 903: symbols defined. ! 904: ! 905: Turn off hiding by calling show-ifdef." ! 906: ! 907: (interactive) ! 908: (message "Hiding...") ! 909: (if (not hide-ifdef-mode) ! 910: (hide-ifdef-mode 1)) ; turn on hide-ifdef-mode ! 911: (if hide-ifdef-hiding ! 912: (show-ifdefs)) ; Otherwise, deep confusion. ! 913: (if buffer-read-only (toggle-read-only)) ; make it writable temporarily ! 914: (setq selective-display t) ! 915: (setq hide-ifdef-hiding t) ! 916: (hide-ifdef-guts) ! 917: (if (or hide-ifdef-read-only hif-outside-read-only) ! 918: (toggle-read-only) ; make it read only ! 919: ) ! 920: (message "Hiding done") ! 921: ) ! 922: ! 923: ! 924: (defun show-ifdefs () ! 925: "Cancel the effects of hide-ifdef. The contents of all #ifdefs is shown." ! 926: (interactive) ! 927: (if buffer-read-only (toggle-read-only)) ; make it writable temporarily ! 928: (setq selective-display nil) ; defaults ! 929: (hif-show-all) ! 930: (if hif-outside-read-only ! 931: (toggle-read-only)) ; make it read only ! 932: (setq hide-ifdef-hiding nil) ! 933: ) ! 934: ! 935: ! 936: (defun hif-find-ifdef-block () ! 937: "Utilitiy for hide and show ifdef-block. Set top and bottom of ifdef block." ! 938: (let (max-bottom) ! 939: (save-excursion ! 940: (beginning-of-line) ! 941: (if (not (or (hif-looking-at-else) (hif-looking-at-ifX))) ! 942: (up-ifdef)) ! 943: (setq top (point)) ! 944: (hif-ifdef-to-endif) ! 945: (setq max-bottom (1- (point))) ! 946: ) ! 947: (save-excursion ! 948: (beginning-of-line) ! 949: (if (not (hif-looking-at-endif)) ! 950: (hif-find-next-relevant)) ! 951: (while (hif-looking-at-ifX) ! 952: (hif-ifdef-to-endif) ! 953: (hif-find-next-relevant) ! 954: ) ! 955: (setq bottom (min max-bottom (1- (point)))) ! 956: )) ! 957: ) ! 958: ! 959: ! 960: (defun hide-ifdef-block () ! 961: "Hide the ifdef block (true or false part) enclosing or before the cursor." ! 962: (interactive) ! 963: (if (not hide-ifdef-mode) ! 964: (hide-ifdef-mode 1)) ! 965: (if buffer-read-only (toggle-read-only)) ! 966: (setq selective-display t) ! 967: (let (top bottom) ! 968: (hif-find-ifdef-block) ; set top and bottom - dynamic scoping ! 969: (hide-ifdef-region top bottom) ! 970: (if hide-ifdef-lines ! 971: (progn ! 972: (hif-hide-line top) ! 973: (hif-hide-line (1+ bottom)))) ! 974: (setq hide-ifdef-hiding t) ! 975: ) ! 976: (if (or hide-ifdef-read-only hif-outside-read-only) ! 977: (toggle-read-only)) ! 978: ) ! 979: ! 980: ! 981: (defun show-ifdef-block () ! 982: "Show the ifdef block (true or false part) enclosing or before the cursor." ! 983: (interactive) ! 984: (let ((old-read-only buffer-read-only)) ! 985: (if old-read-only (toggle-read-only)) ! 986: (if hide-ifdef-lines ! 987: (save-excursion ! 988: (beginning-of-line) ! 989: (hif-show-ifdef-region (1- (point)) (progn (end-of-line) (point)))) ! 990: ! 991: (let (top bottom) ! 992: (hif-find-ifdef-block) ! 993: (hif-show-ifdef-region (1- top) bottom)) ! 994: ) ! 995: ! 996: ; restore read only status since we dont know if all is shown. ! 997: (if old-read-only (toggle-read-only)) ! 998: )) ! 999: ! 1000: ! 1001: ! 1002: ;;; defininition alist support ! 1003: ! 1004: (defvar hide-ifdef-define-alist nil ! 1005: "A global assoc list of pre-defined symbol lists") ! 1006: ! 1007: (defun hif-compress-define-list (env) ! 1008: "Compress the define list ENV into a list of defined symbols only." ! 1009: (let ((defs (mapcar '(lambda (arg) ! 1010: (if (hif-lookup (car arg)) (car arg))) ! 1011: env)) ! 1012: (new-defs nil)) ! 1013: (while defs ! 1014: (if (car defs) ! 1015: (setq new-defs (cons (car defs) new-defs))) ! 1016: (setq defs (cdr defs))) ! 1017: new-defs ! 1018: )) ! 1019: ! 1020: (defun hide-ifdef-set-define-alist (name) ! 1021: "Set the association for NAME to hide-ifdef-env." ! 1022: (interactive "SSet define list: ") ! 1023: (setq hide-ifdef-define-alist ! 1024: (cons (cons name (hif-compress-define-list hide-ifdef-env)) ! 1025: hide-ifdef-define-alist)) ! 1026: ) ! 1027: ! 1028: (defun hide-ifdef-use-define-alist (name) ! 1029: "Set hide-ifdef-env to the define list specified by NAME." ! 1030: (interactive "SUse define list: ") ! 1031: (let ((define-list (assoc name hide-ifdef-define-alist))) ! 1032: (if define-list ! 1033: (setq hide-ifdef-env ! 1034: (mapcar '(lambda (arg) (cons arg t)) ! 1035: (cdr define-list))) ! 1036: (error "No define list for %s" name)) ! 1037: (if hide-ifdef-hiding (hide-ifdefs)) ! 1038: ) ! 1039: ) ! 1040: ! 1041: ;===%%SF%% exports (End) ===
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.