;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(byte-code "\300\301!\210\300\302!\210\303\304\305\306\307\310%\210\311\312\313\314\315DD\316\317\320%\210\311\321\313\314\322DD\323\317\320%\210\311\324\313\314\325DD\326\317\320%\210\311\327\313\314\330DD\331\317\320\332\333&\210\334\327\335\336\332\333%\210\311\337\313\314\340DD\341\317\342\332\343&\210\344\345\346\305#\210\347\211\203\202\211@\345
N\203{\346
N\204{\350\346\345N#\210
A\266\202\202a\210\351\345\346\352#\210\311\346\313\314\353DD\354\317\320\332\343&\210\311\355\313\314\356DD\357\317\360\332\343&\207" [require cc-mode cl-lib custom-declare-group hide-ifdef nil "Hide selected code within `ifdef'." :group c custom-declare-variable hide-ifdef-initially funcall function #[0 "\300\207" [nil] 1 #1=""] "Non-nil means call `hide-ifdefs' when Hide-Ifdef mode is first activated." :type boolean hide-ifdef-read-only #[0 "\300\207" [nil] 1 #1#] "Set to non-nil if you want buffer to be read-only while hiding text." hide-ifdef-lines #[0 "\300\207" [nil] 1 #1#] "Non-nil means hide the #ifX, #else, and #endif lines." hide-ifdef-shadow #[0 "\300\207" [nil] 1 #1#] "Non-nil means shadow text instead of hiding it." :version "23.1" custom-declare-face ((t (:inherit shadow))) "Face for shadowing ifdef blocks." hide-ifdef-exclude-define-regexp #[0 "\300\207" [nil] 1 #1#] "Ignore #define names if those names match this exclusion pattern." (choice (const nil) string) "25.1" defvaralias hide-ifdef-expand-reinclusion-protection hide-ifdef-expand-reinclusion-guard (saved-value saved-variable-comment) put make-obsolete-variable "28.1" #[0 "\300\207" [t] 1 #1#] "Non-nil means don't hide an entire header file enclosed by #ifndef...#endif.\nMost C/C++ headers are usually wrapped with ifdefs to prevent re-inclusion:\n\n  ----- beginning of file -----\n  #ifndef _XXX_HEADER_FILE_INCLUDED_\n  #define _XXX_HEADER_FILE_INCLUDED_\n     xxx\n     xxx\n     xxx...\n  #endif\n  ----- end of file -----\n\nThe first time we visit such a file, _XXX_HEADER_FILE_INCLUDED_ is\nundefined, and so nothing is hidden.  The next time we visit it, everything will\nbe hidden.\n\nThis behavior is generally undesirable.  If this option is non-nil, the\noutermost #if is always visible." hide-ifdef-header-regexp #[0 "\300\207" ["\\.h\\(h\\|xx\\|pp\\|\\+\\+\\)?\\'"] 1 #1#] "C/C++ header file name patterns to determine if current buffer is a header.\nEffective only if `hide-ifdef-expand-reinclusion-guard' is t." regexp] 8)
#@70 Keymap used by `hide-ifdef-mode' under `hide-ifdef-mode-prefix-key'.
(defvar hide-ifdef-mode-submap (byte-code "\300 \301
\302\303#\210\301
\304\305#\210\301
\306\307#\210\301
\310\311#\210\301
\312\313#\210\301
\314\315#\210\301
\316\317#\210\301
\320\321#\210\301
\322\323#\210\301
\324\325#\210\301
\326\327#\210\301
\330\331#\210\332\333\334#\210\332\335\334#\210\207" [make-sparse-keymap define-key "d" hide-ifdef-define "u" hide-ifdef-undef "D" hide-ifdef-set-define-alist "U" hide-ifdef-use-define-alist "h" hide-ifdefs "s" show-ifdefs "" hide-ifdef-block "" show-ifdef-block "e" hif-evaluate-macro "C" hif-clear-all-ifdef-defined "" hide-ifdef-toggle-read-only "" hide-ifdef-toggle-shadowing substitute-key-definition read-only-mode hide-ifdef-toggle-outside-read-only toggle-read-only] 5) (#$ . 2517))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\315\310\316&\210\300\317\302\303\320DD\321\306\322\310\316&\210\300\323\302\303\324DD\325\306\322\310\316&\207" [custom-declare-variable hide-ifdef-mode-prefix-key funcall function #[0 "\300\207" ["@"] 1 #1=""] "Prefix key for all Hide-Ifdef mode commands." :type key-sequence :version "27.1" hide-ifdef-verbose #[0 "\300\207" [nil] 1 #1#] "Show some defining symbols on hiding for a visible feedback." boolean "28.1" hide-ifdef-evalulate-enter-hook #[0 "\300\207" [nil] 1 #1#] "Hook function to be called when entering `hif-evaluate-macro'." hook hide-ifdef-evalulate-leave-hook #[0 "\300\207" [nil] 1 #1#] "Hook function to be called when leaving `hif-evaluate-macro'."] 8)
#@37 Keymap used with `hide-ifdef-mode'.
(defvar hide-ifdef-mode-map (byte-code "\302 \303
	#\210\207" [hide-ifdef-mode-prefix-key hide-ifdef-mode-submap make-sparse-keymap define-key] 5) (#$ . 4111))
#@29 Menu for `hide-ifdef-mode'.
(defvar hide-ifdef-mode-menu nil (#$ . 4314))
(easy-menu-do-define 'hide-ifdef-mode-menu hide-ifdef-mode-map "Menu for `hide-ifdef-mode'." '("Hide-Ifdef" ["Hide some ifdefs" hide-ifdefs :help "Hide the contents of some #ifdefs"] ["Show all ifdefs" show-ifdefs :help "Cancel the effects of `hide-ifdef': show the contents of all #ifdefs"] ["Hide ifdef block" hide-ifdef-block :help "Hide the ifdef block (true or false part) enclosing or before the cursor"] ["Show ifdef block" show-ifdef-block :help "Show the ifdef block (true or false part) enclosing or before the cursor"] ["Define a variable..." hide-ifdef-define :help "Define a VAR so that #ifdef VAR would be included"] ["Undefine a variable..." hide-ifdef-undef :help "Undefine a VAR so that #ifdef VAR would not be included"] ["Define an alist..." hide-ifdef-set-define-alist :help "Set the association for NAME to `hide-ifdef-env'"] ["Use an alist..." hide-ifdef-use-define-alist :help "Set `hide-ifdef-env' to the define list specified by NAME"] ["Toggle read only" hide-ifdef-toggle-read-only :style toggle :selected hide-ifdef-read-only :help "Buffer should be read-only while hiding text"] ["Toggle shadowing" hide-ifdef-toggle-shadowing :style toggle :selected hide-ifdef-shadow :help "Text should be shadowed instead of hidden"]))
#@34 Non-nil when text may be hidden.
(defvar hide-ifdef-hiding nil (#$ . 5645))
(byte-code "\301\236\204\n\302B\301\207" [minor-mode-alist hide-ifdef-hiding (hide-ifdef-hiding " Hiding")] 2)
#@51 Syntax table used for tokenizing #if expressions.
(defvar hide-ifdef-syntax-table (byte-code "\301!\302\303\304#\210\302\305\306#\210\302\307\306#\210\207" [c-mode-syntax-table copy-syntax-table modify-syntax-entry 95 "w" 38 "." 124] 5) (#$ . 5842))
#@47 An alist of defined symbols and their values.
(defvar hide-ifdef-env nil (#$ . 6102))
#@171 This variable is a backup of the previously cleared `hide-ifdef-env'.
This backup prevents any accidental clearance of `hide-ifdef-env' by
`hif-clear-all-ifdef-defined'.
(defvar hide-ifdef-env-backup nil (#$ . 6195))
#@73 Internal variable.  Saves the value of `buffer-read-only' while hiding.
(defvar hif-outside-read-only nil (#$ . 6418))
#@99 Non-nil if Hide-Ifdef mode is enabled.
Use the command `hide-ifdef-mode' to change this variable.
(defvar hide-ifdef-mode nil (#$ . 6543))
(make-variable-buffer-local 'hide-ifdef-mode)
#@2138 Toggle features to hide/show #ifdef blocks (Hide-Ifdef mode).

This is a minor mode.  If called interactively, toggle the `Hide-Ifdef
mode' mode.  If the prefix argument is positive, enable the mode, and
if it is zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable the
mode if ARG is nil, omitted, or is a positive number.  Disable the
mode if ARG is a negative number.

To check whether the minor mode is enabled in the current buffer,
evaluate `hide-ifdef-mode'.

The mode's hook is called both when the mode is enabled and when it is
disabled.

Hide-Ifdef mode is a buffer-local minor mode for use with C and
C-like major modes.  When enabled, 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'
        An association list of defined and undefined symbols for the
        current project.  Initially, the global value of `hide-ifdef-env'
        is used.  This variable was a buffer-local variable, which limits
        hideif to parse only one C/C++ file at a time.  We've extended
        hideif to support parsing a C/C++ project containing multiple C/C++
        source files opened simultaneously in different buffers.  Therefore
        `hide-ifdef-env' can no longer be buffer local but must be global.

`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'.

`hide-ifdef-lines'
        Set to non-nil to not show #if, #ifdef, #ifndef, #else, and
        #endif lines when hiding.

`hide-ifdef-initially'
        Indicates whether `hide-ifdefs' should be called when Hide-Ifdef mode
        is activated.

`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}

(fn &optional ARG)
(defalias 'hide-ifdef-mode #[256 "\306 
\307=\203
?\202
\247\203
\310W\203\311\202\312\313\301!\2031\314\300	\"\2031\300	B\203s\315\302!\316\303!\210\315\303!\316\304!\210\315\304!\316\317!\210
\316\320!\210\312\321\322\323\311\312$\210\324\325!\210'\203m\326 \210\202\202\327 \210\202\202\330\320!\210\331\332!\210\f\203\202\327 \210\333\334\203\214\335\202\215\336\"\210\337\340!\203\257\306 \203\241\211\306 \232\203\257\341\342\203\253\343\202\254\344\345#\210\210\346 \210\207" [hide-ifdef-mode local-minor-modes hide-ifdef-env hide-ifdef-expand-reinclusion-guard hide-ifdef-hiding buffer-read-only current-message toggle 1 nil t boundp delq default-value make-local-variable hif-outside-read-only line-move-ignore-invisible add-hook change-major-mode-hook #[0 "\300\301!\207" [hide-ifdef-mode -1] 2] add-to-invisibility-spec (hide-ifdef . t) hide-ifdefs show-ifdefs kill-local-variable remove-from-invisibility-spec (hide-ifdef . t) run-hooks hide-ifdef-mode-hook hide-ifdef-mode-on-hook hide-ifdef-mode-off-hook called-interactively-p any message "Hide-Ifdef mode %sabled%s" "en" "dis" " in current buffer" force-mode-line-update hide-ifdef-initially] 7 (#$ . 6736) (byte-code "\203\n\301!\202\302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)])
(defvar hide-ifdef-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\303\301\305\306#\210\303\301\307\310C#\210\311\312\313\314\300!\205#\310\211%\207" [hide-ifdef-mode-map hide-ifdef-mode-hook variable-documentation put "Hook run after entering or leaving `hide-ifdef-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" custom-type hook standard-value nil add-minor-mode hide-ifdef-mode " Ifdef" boundp] 6)
#@216 Clears all symbols defined in `hide-ifdef-env'.
It will backup this variable to `hide-ifdef-env-backup' before clearing to
prevent accidental clearance.
When prefixed, it swaps current symbols with the backup ones.
(defalias 'hif-clear-all-ifdef-defined #[0 "\203	\203\303\304\305	G\"!\205	\211\306\307!\207\306\310!\207\303\304\311\nG\"!\2053\n\203.\n\312\306\313!\207" [current-prefix-arg hide-ifdef-env-backup hide-ifdef-env y-or-n-p format "Restore all %d #defined symbols just cleared? " message "Backup symbols restored." "No backup symbol to restore." "Clear all %d #defined symbols? " nil "All defined symbols cleared."] 4 (#$ . 10698) nil])
#@151 Show all of the text in the current buffer.
If there is a marked region from START to END it only shows the symbols within.

(fn &optional START END)
(defalias 'hif-show-all #[512 "\300\206e\206d\"\207" [hif-show-ifdef-region] 5 (#$ . 11368) (byte-code "\300 \203\301 \302 D\207edD\207" [use-region-p region-beginning region-end] 2)])
(defalias 'hif-after-revert-function #[0 "\205
	\205
\302\303\211\304#\207" [hide-ifdef-mode hide-ifdef-hiding hide-ifdefs nil t] 4])
(add-hook 'after-revert-hook 'hif-after-revert-function)
(defalias 'hif-end-of-line #[0 "\300\210\301\302\303\300x\"\302U\205\304\210\202\207" [nil logand 1 "\\\\" 2] 4])
#@177 This function merges nearby ifdef regions to form a bigger overlay.
The region is defined by START and END.  This will decrease the number of
overlays created.

(fn START END)
(defalias 'hif-merge-ifdef-region #[514 "\214~\210\300\301Ze]Se]\"\300Td^\301\\d^\"\302\211\211\211\211\203P\211@\303
\304\"\203I	\305!^\262\306!]\262\307
#\210\310\"\210\211\262
A\266\202\202\210\211\203\204\211@\303
\304\"\203}	\305!^\262\306!]\262\307
#\210\310\"\210\211\262
A\266\202\202R\210\203\254\203\254\305!\305!^\306!\306!]\311!\210\307#\210\310\"\266\206\261\266\206)\207" [overlays-in 2 nil overlay-get hide-ifdef overlay-start overlay-end move-overlay hif-merge-ifdef-region delete-overlay] 14 (#$ . 12032)])
#@18 

(fn START END)
(defalias 'hide-ifdef-region-internal #[514 "\301\"?\205%\302\"\303
\304\305#\210\203\303
\306\300#\202#\303
\307\304#\262
\207" [hide-ifdef-shadow hif-merge-ifdef-region make-overlay overlay-put hide-ifdef t face invisible] 7 (#$ . 12794)])
#@145 START is the start of a #if, #elif, or #else form.  END is the ending part.
Everything including these lines is made invisible.

(fn START END)
(defalias 'hide-ifdef-region #[514 "\212
b\210\300 \210`\262\211b\210\300 \210`\262
\301\")\207" [hif-end-of-line hide-ifdef-region-internal] 5 (#$ . 13069)])
#@67 Everything between START and END is made visible.

(fn START END)
(defalias 'hif-show-ifdef-region #[514 "\300\"G\301\302\303$\210\211\300\"GU?\207" [overlays-in remove-overlays hide-ifdef t] 8 (#$ . 13381)])
#@53 Evaluate hideif internal representation.

(fn FORM)
(defalias 'hif-eval #[257 "\300
!\211;\203\301\302\303#\206\207\211\207" [eval get-text-property 0 hif-value] 6 (#$ . 13602)])
#@140 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 hide-ifdef-evaluator 'hif-eval (#$ . 13793))
#@42 ...is by default considered to be false.
(defvar hif-undefined-symbol nil (#$ . 13991))
#@63 Prepend (VAR VALUE) pair to `hide-ifdef-env'.

(fn VAR VALUE)
(defalias 'hif-set-var #[514 "

BB\211\207" [hide-ifdef-env] 4 (#$ . 14085)])
(defconst hif-predefine-alist '((__LINE__ . hif-__LINE__) (__FILE__ . hif-__FILE__) (__COUNTER__ . hif-__COUNTER__) (__cplusplus . hif-__cplusplus) (__DATE__ . hif-__DATE__) (__TIME__ . hif-__TIME__) (__STDC__ . hif-__STDC__) (__STDC_VERSION__ . hif-__STDC_VERSION__) (__STDC_HOST__ . hif-__STDC_HOST__) (__BASE_FILE__ . hif-__FILE__)))
#@12 

(fn VAR)
(defalias 'hif-lookup #[257 "\304\300!\203\203\305
!\206.\211	\236\211\203\211A\202,
\n\236\211\262\203+\211A \202,\262
\207" [semantic-c-takeover-hideif hide-ifdef-env hif-predefine-alist hif-undefined-symbol boundp semantic-c-hideif-lookup] 4 (#$ . 14570)])
#@12 

(fn VAR)
(defalias 'hif-defined #[257 "\303\304\300!\203\203\305!\207
	\236\203\306\207
\n\236\211\262\203(\211A \203(\306\207\307\207" [semantic-c-takeover-hideif hide-ifdef-env hif-predefine-alist nil boundp semantic-c-hideif-defined 1 0] 4 (#$ . 14860)])
(defconst hif-cpp-prefix "\\(^\\|
\\)[ 	]*#[ 	]*")
(defconst hif-ifxdef-regexp (concat hif-cpp-prefix "if\\(n\\)?def"))
(defconst hif-ifndef-regexp (concat hif-cpp-prefix "ifndef"))
(defconst hif-ifx-regexp (concat hif-cpp-prefix "if\\(n?def\\)?[ 	]+"))
(defconst hif-elif-regexp (concat hif-cpp-prefix "elif"))
(defconst hif-else-regexp (concat hif-cpp-prefix "else"))
(defconst hif-endif-regexp (concat hif-cpp-prefix "endif"))
(defconst hif-ifx-else-endif-regexp (concat hif-ifx-regexp #1="\\|" hif-elif-regexp #1# hif-else-regexp #1# hif-endif-regexp))
(defconst hif-macro-expr-prefix-regexp (concat hif-cpp-prefix "\\(if\\(n?def\\)?\\|elif\\|define\\)[ 	]+"))
(defconst hif-white-regexp "[ 	]*")
(defconst hif-define-regexp (concat hif-cpp-prefix "\\(define\\|undef\\)"))
(defconst hif-id-regexp "[[:alpha:]_][[:alnum:]_]*")
(defconst hif-macroref-regexp (concat hif-white-regexp #1="\\(" hif-id-regexp "\\)\\((" hif-white-regexp #1# hif-id-regexp "\\)?" hif-white-regexp "\\(," hif-white-regexp hif-id-regexp hif-white-regexp "\\)*\\(\\.\\.\\.\\)?" hif-white-regexp ")\\)?"))
(defconst hif-numtype-suffix-regexp "\\(\\(ll[uU]\\|LL[uU]\\|[uU]?ll\\|[uU]?LL\\|[lL][uU]\\|[uU][lL]\\|[uU][hH]\\)[kKrR]?\\|[dD][dDfFlL]\\|[uUlLfF]\\)")
(defconst hif-bin-regexp (concat "[+-]?0[bB]\\([01']+\\)" hif-numtype-suffix-regexp "?"))
(defconst hif-hex-regexp (concat "[+-]?0[xX]\\([[:xdigit:]']+\\)" hif-numtype-suffix-regexp "?"))
(defconst hif-oct-regexp (concat "[+-]?0[0-7']+" hif-numtype-suffix-regexp "?"))
(defconst hif-dec-regexp (concat "[+-]?\\(0\\|[1-9][0-9']*\\)" hif-numtype-suffix-regexp "?"))
(defconst hif-decfloat-regexp "\\(?:\\([+-]?[0-9]+\\)\\([eE][+-]?[0-9]+\\)?[dD]?[fFlL]?\\|\\([+-]?[0-9]+\\)\\.\\([eE][+-]?[0-9]+\\)?[dD]?[dDfFlL]?\\|\\([+-]?[0-9]*\\.[0-9]+\\)\\([eE][+-]?[0-9]+\\)?[dD]?[dDfFlL]?\\)")
(defconst hif-hexfloat-regexp "[+-]?\\(?:0[xX]\\([[:xdigit:]']+\\)[pP]\\([+-]?[0-9']+\\)[fFlL]?\\|0[xX]\\([[:xdigit:]']+\\)\\.[pP]\\([+-]?[0-9']+\\)[fFlL]?\\|0[xX]\\([[:xdigit:]']*\\)\\.\\([[:xdigit:]']+\\)[pP]\\([+-]?[0-9']+\\)[fFlL]?\\)")
(defconst hif-token-alist '(("||" . hif-or) ("&&" . hif-and) ("|" . hif-logior) ("^" . hif-logxor) ("&" . hif-logand) ("<<" . hif-shiftleft) (">>" . hif-shiftright) ("==" . hif-equal) ("=" . hif-assign) ("!=" . hif-notequal) ("##" . hif-token-concat) ("!" . hif-not) ("~" . hif-lognot) ("(" . hif-lparen) (")" . hif-rparen) (">" . hif-greater) ("<" . hif-less) (">=" . hif-greater-equal) ("<=" . hif-less-equal) ("+" . hif-plus) ("-" . hif-minus) ("*" . hif-multiply) ("/" . hif-divide) ("%" . hif-modulo) ("?" . hif-conditional) (":" . hif-colon) ("," . hif-comma) ("#" . hif-stringify) ("..." . hif-etc) ("defined" . hif-defined)))
(defconst hif-valid-token-list (mapcar 'cdr hif-token-alist))
(defconst hif-token-regexp (byte-code "\302\303\304\305\306\307	\"\310\"\311\260\207" [hif-numtype-suffix-regexp hif-token-alist "\\([+-]?0[xXbB]\\([[:xdigit:]']+\\)?\\.?\\([[:xdigit:]']+\\)?\\([pP]\\([+-]?[0-9]+\\)\\)?" "?\\)\\|\\(\\([+-]?[0-9']+\\(\\.[0-9']*\\)?\\)\\([eE][+-]?[0-9]+\\)?" "?\\)\\|" regexp-opt mapcar car t "\\|\\(\\w+\\)"] 9))
(defconst hif-unicode-prefix-regexp "\\(?:u8R?\\|[uUL]R?\\|R\\)")
(defconst hif-string-literal-regexp (concat hif-unicode-prefix-regexp "?\\(\"\\(?:[^\"\\]\\|\\\\.\\)*\"\\)"))
#@79 A full REGEXP match of STRING instead of partially match.

(fn REGEXP STRING)
(defalias 'hif-full-match #[514 "\300\301\302Q\"\207" [string-match "\\`" "\\'"] 6 (#$ . 18415)])
#@64 Check if STRING is a valid C(++) numeric literal.

(fn STRING)
(defalias 'hif-is-number #[257 "\304\"\206\304	\"\206\304\n\"\206\304\"\207" [hif-dec-regexp hif-hex-regexp hif-oct-regexp hif-bin-regexp hif-full-match] 4 (#$ . 18599)])
#@71 Check if STRING is a valid C(++) floating point literal.

(fn STRING)
(defalias 'hif-is-float #[257 "\302\"\206\302	\"\207" [hif-decfloat-regexp hif-hexfloat-regexp hif-full-match] 4 (#$ . 18851)])
#@50 Delete CHAR in STRING inplace.

(fn CHAR STRING)
(defalias 'hif-delete-char-in-string #[514 "\211G\300
\301V\203
S\262H=\204H
B\262
\202\211\260
\207" [nil 0] 6 (#$ . 19060)])
#@203 Convert a C(++) decimal floating formatted string into float.
Assuming we've just regexp-matched with `hif-decfloat-regexp' and it matched.
if REMATCH is t, do a rematch.

(fn STRING &optional FIX EXP)
(defalias 'hif-string-to-decfloat #[769 "
\204\211\203\301\302\"\262\301\302\"\262
\202J\301\302\"\262\303\"\210\304\305\"\2064\304\306\"\2064\304\307\"\262\304\310\"\206H\304\311\"\206H\304\312\"\262
\313!\262\211G\314U\203Z\314\202`\313\315\305\"!\262

\316\317\"_\207" [hif-decfloat-regexp hif-delete-char-in-string 39 hif-full-match match-string 1 3 5 2 4 6 string-to-number 0 substring-no-properties expt 10] 7 (#$ . 19255)])
#@200 Convert a C++17 hex float formatted string into float.
Assuming we've just regexp-matched with `hif-hexfloat-regexp' and it matched.
if REMATCH is t, do a rematch.

(fn STRING &optional INT FRA EXP)
(defalias 'hif-string-to-hexfloat #[1025 "\301H\302=\203\f\303\202
\304\204\204
\203.\305\306\"\262\305\306\"\262\305\306\"\262\202p\305\306\"\262\307\"\210\310\311\"\206P\310\312\"\206P\310\313\"\262\310\314\"\206g\310\315\"\206g\310\316\"\262\310\317\"\262G\301U\203{\301\202\320\321\"\262G\301U\203\214\301\202\226\320\321\"\322\323G\"\245\262
G\301U\203\243\301\202\246\320!\262\211\\_\322\324\"_\207" [hif-hexfloat-regexp 0 45 -1.0 1.0 hif-delete-char-in-string 39 hif-full-match match-string 1 3 5 2 4 6 7 string-to-number 16 expt 16.0 2.0] 9 (#$ . 19924)])
#@89 Like `string-to-number', but it understands C(++) literals.

(fn STRING &optional BASE)
(defalias 'hif-string-to-number #[513 "\300\301\"\262\302\"\207" [hif-delete-char-in-string 39 string-to-number] 5 (#$ . 20756)])
#@10 

(fn C)
(defalias 'hif-is-white #[257 "\211\300>\207" [(32 9 10 13)] 3 (#$ . 20984)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put hif-is-white speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@141 Convert STRING into a hideif mode internal token.
Assuming we've just performed a `hif-token-regexp' lookup.

(fn STRING &optional REMATCH)
(defalias 'hif-strtok #[513 "\303\211\211\211\211\211\211\211\211\211\n\203\304
\"\210\262\n\305\306\"\203\227\305\307\"\262\305\310\"\211\262\204;\305\311\"\203F\312\f#\202t\313H\262\314\f\211G\315V\203o\316=\204k\317>\203o
\315H\316=\203o\306\202s\311\211\262\"\262\211\203\212\305\320\"\204\212\321>\204\212
\207\322\313\315\323D$\210\207\305\315\"\203
\305\324\"\262\322\313\315\323\305\325\"\211\262\f\204\272\203\312\326\305\327\"$\202
\313H\330=\203\327\331\202\330\315\262\314\332\333\325
Z\331\"\"\333\324
Z\331\"H\211\262\334=\204

	\335=\203
\336\202
\327\"_D$\210\207\305\337\"\211\262\n\203#
\340		\341#A\207\303\342\f!\207" [hif-token-regexp hif-token-alist hif-simple-token-only nil string-match match-string 8 9 11 10 hif-string-to-decfloat 0 hif-string-to-number 1 48 (45 43) 12 (45 43) add-text-properties hif-value 3 5 hif-string-to-hexfloat 2 45 -1 substring-no-properties ash 120 88 16 14 assoc string-equal intern-safe] 23 (#$ . 21216)])
#@91 If we're currently within a C(++) comment, skip them backwards.

(fn &optional START END)
(defalias 'hif-backward-comment #[512 "\211\206`\262
\211S\300V\203 \211Sf\211\301>\262
\203 \211S\262
\202\302\211\211\211\211\211\206/\303 \210`\262\262TW\203U
\304\305f\"\203$
\304\305Tf\"\203\240
\203_SU\203_\202`\262T\211\262W\203\304\306f\"\204\304\307f\"\203b\211\203\225\211@AU\203\225\211
A\262\242@\202\226B
B\262
\202N
\304\310Tf\"\203N

\203\271SU\203\271\202\272\262\211\203\322\211@AU\203\322\211
A\262\242@\202\323\262\311\\\262\3122 
TW\203
\304\310f\"\203\372\304\305Tf\"\204

T\262\202\337T\211\262TB
B\262
\313\312\302\"\210\202\337B
B\211\2620\210\202N
\304\314f\"\203H
\203?

SU\203?
\262\202N
\262\262\202N
\302\262\302\262T\262\2025\211@\262\203r
@Y\203r
AX\203r
@\202t
\262S\300V\203\217
Sf\211\301>\262
\203\217
S\262\202v
b\207" [1 (32 9 10 13) nil beginning-of-line char-equal 47 10 13 42 2 break throw 32] 11 (#$ . 22420)])
#@78 Separate string between START and END into a list of tokens.

(fn START END)
(defalias 'hif-tokenize #[514 "\304\211\305\306 p\307\310#\216\311	!\210\212\214\312\"\262}\210b\210\313d!\210`W\203\242\314\315!\2038\316u\210\202\"\314\n!\203c\317\320\321!!\262\322\225b\210\314\323!\203[\324\322\321\325$\210\322\225b\210B\262\202\"\314!\203\215\322\225b\210\326\317\320\322!!!\262B\262\314\323!\203\"\327B\262\322\225b\210\202\"\314\330!\203\231\321u\210\202\"\331\332\333 \"\210\202\"*@\327=\203\256A\262\237)\207" [hif-simple-token-only hide-ifdef-syntax-table hif-string-literal-regexp hif-token-regexp nil t syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table hif-backward-comment forward-comment looking-at "\\\\\n" 2 substring-no-properties match-string 1 0 "[ 	]+" add-text-properties (hif-space t) hif-strtok hif-space "
" error "Bad #if expression: %s" buffer-string] 11 (#$ . 23492)])
#@98 Pop the next token from token-list into the let variable `hif-token'.

(fn &optional KEEP-SPACE)
(defalias 'hif-nexttoken #[256 "	\211A\242
\203\211\302=\203\302=\202\302=\204
\210\207" [hif-token hif-token-list hif-space] 4 (#$ . 24482)])
#@60 Split current numeric token into two (hif-plus/minus num).
(defalias 'hif-split-signed-token #[0 "\302\211\211;\205G\303\304\305#\211\262\205G\304H\211\262\306>\205G
\307=\203*\310\262
\2021\311\262
[\262\312\302O\313\304\312\305D$\210	B\211\211\207" [hif-token hif-token-list nil get-text-property 0 hif-value (43 45) 43 hif-plus hif-minus 1 add-text-properties] 8 (#$ . 24741)])
#@11 

(fn ID)
(defalias 'hif-if-valid-identifier-p #[257 "\211\247\206\211;\206\211:?\205\211\300=?\207" [defined] 3 (#$ . 25148)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put hif-if-valid-identifier-p speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@89 "Upgrade" hif-define XXX to `(hif-define XXX)' so it won't be substituted.

(fn TOKENS)
(defalias 'hif-define-operator #[257 "\302
>\203m\211\303\211\303\211\262\304\305!\203i	\302=\203a\304 \210	\306=\211\262\203*\304 \210	\211\262\211\247\206A\211;\206A\211:?\205A\211\307=?\262
\204L\310\311\"\210\211\203[\304 \312=\204[\310\313!\210\302\306\312F	B\262\202\237*\207\207" [hif-token-list hif-token hif-defined nil hif-nexttoken t hif-lparen defined error "`defined' followed by non-identifier: %S" hif-rparen "Missing right parenthesis for `defined'"] 8 (#$ . 25439)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias hif-flatten flatten-tree nil make-obsolete "27.1"] 4)
#@56 Prevent two or more consecutive E in list L.

(fn L E)
(defalias 'hif-keep-single #[514 "\211>\203/\300\211\211
\262@\262A\262
\203,=\203$
=\204	

B\262
\202	\211\237\207
\207" [nil] 7 (#$ . 26160)])
#@415 Perform expansion on TOKENS till everything expanded.
Self-reference (directly or indirectly) tokens are not expanded.
EXPAND_LIST is the list of macro names currently being expanded, used for
detecting self-reference.
Function-like macros with calling depth LEVEL 0 does not expand arguments,
this is to emulate the stringification behavior of C++ preprocessor.

(fn TOKENS &optional MACRONAME EXPAND_LIST LEVEL)
(defalias 'hif-expand-token-list #[1025 "\211C\3032\361\304\305\306\307!!!\304\211\211\242\203\242\202\310\240\210\203+B\262\211A\262\242\211\262\203\352
>\203D\311\303\n\"\210
>\204T
\247\204T
;\203X
\202\343\312!\211\262\203\342\211<\203\336\211@\313=\203\336\211A@\203\311@\314=\204\225@\315=\203\221A@\314=\203\221A\211\262\204\225
\202\343A\304\242\310U\203\247\316\317!\202\261\320\321\322\"\316\317!\"\323\324\"\n	\242T$\n	B\262*\262
\202\343\323\3258	#\262
\326#\262\211\202\343\211\202\343
B\262\202+\327\237!\266\2040\207" [hif-valid-token-list hif-token-list hif-token self-referencing nil hif-define-operator hif-token-concatenation hif-token-stringification 0 throw hif-lookup hif-define-macro hif-lparen hif-space hif-get-argument-list t mapcar make-closure #[257 "\301
\302\211\300\242T$\207" [V0 hif-expand-token-list nil] 6 "\n\n(fn A)"] hif-expand-token-list hif-macro-supply-arguments 2 cl-substitute flatten-tree] 15 (#$ . 26381)])
#@169 Parse the TOKEN-LIST.
Return translated list in prefix form.  MACRONAME is applied when invoking
macros to prevent self-reference.

(fn TOKEN-LIST &optional MACRONAME)
(defalias 'hif-parse-exp #[513 "\303\304#\304\305 \210\205\306 \203$\307\310\311 \312\n\"@\206\"#\210*\207" [hif-token hif-token-list hif-token-alist hif-expand-token-list nil hif-nexttoken hif-exprlist error "Error: unexpected token at line %d: `%s'" line-number-at-pos rassq] 9 (#$ . 27828)])
#@39 Parse an exprlist: expr { `,' expr }.
(defalias 'hif-exprlist #[0 "\301 \302=\203\211C\303 \210\301 
B\262
\302=\204\n\302
\237B\207\207" [hif-token hif-expr hif-comma hif-nexttoken] 4 (#$ . 28309)])
#@82 Parse an expression as found in #if.
expr : or-expr | or-expr `?' expr `:' expr.
(defalias 'hif-expr #[0 "\301 \302\303=\203,\304 \210\305 \262
\306=\203$\304 \210\303\305 F\262\202\307\310\"\210\202
\207" [hif-token hif-or-expr nil hif-conditional hif-nexttoken hif-expr hif-colon error "Error: unexpected token: %s"] 6 (#$ . 28520)])
#@54 Parse an or-expr : and-expr | or-expr `||' and-expr.
(defalias 'hif-or-expr #[0 "\301 \302=\203\303 \210\302
\301 E\262
\202\207" [hif-token hif-and-expr hif-or hif-nexttoken] 4 (#$ . 28874)])
#@62 Parse an and-expr : logior-expr | and-expr `&&' logior-expr.
(defalias 'hif-and-expr #[0 "\301 \302=\203\303 \210\302
\301 E\262
\202\207" [hif-token hif-logior-expr hif-and hif-nexttoken] 4 (#$ . 29078)])
#@64 Parse a logor-expr : logxor-expr | logor-expr `|' logxor-expr.
(defalias 'hif-logior-expr #[0 "\301 \302=\203\303 \210\302
\301 E\262
\202\207" [hif-token hif-logxor-expr hif-logior hif-nexttoken] 4 (#$ . 29295)])
#@66 Parse a logxor-expr : logand-expr | logxor-expr `^' logand-expr.
(defalias 'hif-logxor-expr #[0 "\301 \302=\203\303 \210\302
\301 E\262
\202\207" [hif-token hif-logand-expr hif-logxor hif-nexttoken] 4 (#$ . 29520)])
#@58 Parse a logand-expr : eq-expr | logand-expr `&' eq-expr.
(defalias 'hif-logand-expr #[0 "\301 \302=\203\303 \210\302
\301 E\262
\202\207" [hif-token hif-eq-expr hif-logand hif-nexttoken] 4 (#$ . 29747)])
#@51 Parse an eq-expr : comp | eq-expr `=='|`!=' comp.
(defalias 'hif-eq-expr #[0 "\301 \302\303>\203\262
\304 \210\211\301 E\262\202
\207" [hif-token hif-comp-expr nil (hif-equal hif-notequal) hif-nexttoken] 5 (#$ . 29962)])
#@70 Parse a comp-expr : logshift | comp-expr `<'|`>'|`>='|`<=' logshift.
(defalias 'hif-comp-expr #[0 "\301 \302\303>\203\262
\304 \210\211\301 E\262\202
\207" [hif-token hif-logshift-expr nil (hif-greater hif-less hif-greater-equal hif-less-equal) hif-nexttoken] 5 (#$ . 30197)])
#@52 Parse a logshift : math | logshift `<<'|`>>' math.
(defalias 'hif-logshift-expr #[0 "\301 \302\303>\203\262
\304 \210\211\301 E\262\202
\207" [hif-token hif-math nil (hif-shiftleft hif-shiftright) hif-nexttoken] 5 (#$ . 30488)])
#@78 Parse an expression with + or -.
       math : muldiv | math `+'|`-' muldiv.
(defalias 'hif-math #[0 "\301 \302\303>\204\304 \203\262
\305 \210\211\301 E\262\202
\207" [hif-token hif-muldiv-expr nil (hif-plus hif-minus) hif-split-signed-token hif-nexttoken] 5 (#$ . 30731)])
#@85 Parse an expression with *,/,%.
       muldiv : factor | muldiv `*'|`/'|`%' factor.
(defalias 'hif-muldiv-expr #[0 "\301 \302\303>\203\262
\304 \210\211\301 E\262\202
\207" [hif-token hif-factor nil (hif-multiply hif-divide hif-modulo) hif-nexttoken] 5 (#$ . 31022)])
#@136 Parse a factor.
factor : `!' factor | `~' factor | `(' exprlist `)' | `defined(' id `)' |
         id `(' parmlist `)' | strings | id.
(defalias 'hif-factor #[0 "\301\267\202]\302 \210\303\304 D\207\302 \210\305\304 D\207\302 \210\306 \307=\204&\310\311\"\207\302 \210\207\302 \210\312=\2057\302 \210\313\211\314>\203C\310\315\"\210
\203T\302 \210\307=\204T\310\316!\210\302 \210\317\320DD\207;\203r\321\322\323#\203o\302 \210\207\324 \207\247\203|\302 \210\207\325>\203\213\302 \210\322\304 E\207\302 \210\312=\203\231\326
!\207\327\320DD\207" [hif-token #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (hif-not 6 hif-lognot 14 hif-lparen 22 hif-defined 42)) hif-nexttoken hif-not hif-factor hif-lognot hif-exprlist hif-rparen error "Bad token in parenthesized expression: %s" hif-lparen t (or and not hif-defined hif-lparen hif-rparen) "Error: unexpected token: %s" "Error: expected \")\" after identifier" hif-defined quote get-text-property 0 hif-value hif-string-concatenation (hif-minus hif-plus) hif-place-macro-invocation hif-lookup] 5 (#$ . 31305)])
#@29 

(fn &optional KEEP-SPACE)
(defalias 'hif-get-argument-list #[256 "\301\302\211\303!\304=\203\301U\204N\305
!@\306=\203\302\262
\307\267\2021T\262\202FS\262\202F\306=\203F\301U\203F\211\237B\262\302\262

B\262
\202\211\237B\262\303!\210
\237\207" [hif-token 0 nil hif-nexttoken hif-rparen last hif-comma #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (hif-lparen 35 hif-rparen 42))] 6 (#$ . 32436)])
#@14 

(fn IDENT)
(defalias 'hif-place-macro-invocation #[257 "\300 \301\302D\302DE\207" [hif-get-argument-list hif-invoke quote] 6 (#$ . 32908)])
#@54 Parse concatenated strings: string | strings string.
(defalias 'hif-string-concatenation #[0 "\301!\302 ;\203\211\303\304O\305\306OP\262
\202\207" [hif-token substring-no-properties hif-nexttoken 0 -1 1 nil] 5 (#$ . 33058)])
#@133 A marker for defined macro with arguments.
This macro cannot be evaluated alone without parameters input.

(fn PARMLIST TOKEN-BODY)
(defalias 'hif-define-macro #[514 "\300\301!\207" [error "Argumented macro cannot be evaluated without passing any parameter"] 4 (#$ . 33296)])
#@47 Stringify a number, string or symbol.

(fn A)
(defalias 'hif-stringify #[257 "\211\247\203	\302
!\207\211;\203\303
!\304\305\306#\205\307P\207\211:\2049\211>\203-\310
	\"@\207\211\306=\2035\307\207\311
!\207\211<\203Y\211\312\313:\203X@\262\211\314!P\262
A\262\202A\207\315\316!\207" [hif-valid-token-list hif-token-alist number-to-string substring-no-properties get-text-property 0 hif-space " " rassq symbol-name nil "" hif-stringify error "Invalid token to stringify"] 7 (#$ . 33578)])
#@12 

(fn STR)
(defalias 'intern-safe #[257 "\211;\205\300
!\207" [intern] 3 (#$ . 34092)])
#@313 Concatenate a list of tokens into a longer token.
Also support weird (but valid) token concatenation like `>' ## `>' becomes `>>'.
Here we take care only those that can be evaluated during preprocessing time and
ignore all those that can only be evaluated at C(++) runtime (like `++', `--'
and `+='...).

(fn L)
(defalias 'hif-token-concat #[257 "\302
\211\203$\211@
>\203\303	\"@\202\304!P\262
A\266\202\202\210\305
\306\"\207" [hif-valid-token-list hif-token-alist nil rassq hif-stringify hif-strtok t] 8 (#$ . 34189)])
#@71 Treat VAL as a hideif number: if it's t or nil, use 1 or 0.

(fn VAL)
(defalias 'hif-mathify #[257 "\211;\203\300\301\302#\206\207\211\303\267\202\304\207\301\207\211\207" [get-text-property 0 hif-value #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 20 nil 22)) 1] 5 (#$ . 34729)])
#@14 

(fn A B C)
(defalias 'hif-conditional #[771 "\300!\301U\204\f\300!\207\300
!\207" [hif-mathify 0] 5 (#$ . 35065)])
#@12 

(fn A B)
(defalias 'hif-and #[514 "\300!\301U?\205\300
!\301U?\207" [hif-mathify 0] 4 (#$ . 35191)])
#@12 

(fn A B)
(defalias 'hif-or #[514 "\300!\301U?\206\300
!\301U?\207" [hif-mathify 0] 4 (#$ . 35303)])
#@10 

(fn A)
(defalias 'hif-not #[257 "\300
!\301U\207" [hif-mathify 0] 3 (#$ . 35414)])
#@10 

(fn A)
(defalias 'hif-lognot #[257 "\300\301!!\207" [lognot hif-mathify] 4 (#$ . 35505)])
#@12 

(fn FUN)
(defalias 'hif-mathify-binop '(macro . #[257 "\300\301\302\303\"\304BF\207" [lambda (a b) format "Like `%s' but treat t and nil as 1 and 0." ((hif-mathify a) (hif-mathify b))] 6 (#$ . 35604)]))
#@12 

(fn A B)
(defalias 'hif-shiftleft #[514 "\300!\262\300
!\262
\301\"\207" [hif-mathify ash] 5 (#$ . 35817)])
#@12 

(fn A B)
(defalias 'hif-shiftright #[514 "\300!\262\300
!\262
\301[\"\207" [hif-mathify ash] 5 (#$ . 35937)])
#@52 Like `*' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-multiply #[514 "\300!\300!_\207" [hif-mathify] 5 (#$ . 36059)])
#@52 Like `/' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-divide #[514 "\300!\300!\245\207" [hif-mathify] 5 (#$ . 36197)])
#@52 Like `%' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-modulo #[514 "\300!\300!\246\207" [hif-mathify] 5 (#$ . 36336)])
#@52 Like `+' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-plus #[514 "\300!\300!\\\207" [hif-mathify] 5 (#$ . 36475)])
#@52 Like `-' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-minus #[514 "\300!\300!Z\207" [hif-mathify] 5 (#$ . 36610)])
#@52 Like `=' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-equal #[514 "\300!\300!U\207" [hif-mathify] 5 (#$ . 36745)])
#@53 Like `/=' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-notequal #[514 "\300!\300!U?\207" [hif-mathify] 5 (#$ . 36880)])
#@52 Like `>' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-greater #[514 "\300!\300!V\207" [hif-mathify] 5 (#$ . 37020)])
#@52 Like `<' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-less #[514 "\300!\300!W\207" [hif-mathify] 5 (#$ . 37157)])
#@53 Like `>=' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-greater-equal #[514 "\300!\300!Y\207" [hif-mathify] 5 (#$ . 37291)])
#@53 Like `<=' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-less-equal #[514 "\300!\300!X\207" [hif-mathify] 5 (#$ . 37435)])
#@57 Like `logior' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-logior #[514 "\300\301!\301!\"\207" [logior hif-mathify] 6 (#$ . 37576)])
#@57 Like `logxor' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-logxor #[514 "\300\301!\301!\"\207" [logxor hif-mathify] 6 (#$ . 37729)])
#@57 Like `logand' but treat t and nil as 1 and 0.

(fn A B)
(defalias 'hif-logand #[514 "\300\301!\301!\"\207" [logand hif-mathify] 6 (#$ . 37882)])
(defalias 'hif-__LINE__ #[0 "\300 \207" [line-number-at-pos] 1])
(defalias 'hif-__FILE__ #[0 "\300\301 !\207" [file-name-nondirectory buffer-file-name] 2])
(defvar hif-__COUNTER__ 0)
(defalias 'hif-__COUNTER__ #[0 "\211T\207" [hif-__COUNTER__] 2])
(defalias 'hif-__cplusplus #[0 "\301\302\303 \"\205\304>\205\305\207" [major-mode string-match "\\.c\\(c\\|xx\\|pp\\|\\+\\+\\)\\'" buffer-file-name (c++-mode cc-mode cpp-mode) 201710] 3])
(defalias 'hif-__DATE__ #[0 "\300\301!\207" [format-time-string "%Y/%m/%d"] 2])
(defalias 'hif-__TIME__ #[0 "\300\301!\207" [format-time-string "%H:%M:%S"] 2])
(defalias 'hif-__STDC__ #[0 "\300\207" [1] 1])
(defalias 'hif-__STDC_VERSION__ #[0 "\300\207" [201710] 1])
(defalias 'hif-__STDC_HOST__ #[0 "\300\207" [1] 1])
#@79 Evaluate a list of EXPR, return the result of the last item.

(fn &rest EXPR)
(defalias 'hif-comma #[128 "\301
\211\203\211@\3021
!\211\2620\210\202\210
A\266\202\202
\207" [hide-ifdef-evaluator nil (error)] 6 (#$ . 38797)])
#@87 Scan token list for `hif-stringify' (`#') token and stringify the next token.

(fn L)
(defalias 'hif-token-stringification #[257 "\300
>\203:\301
\2037
@\300=\203*
A@\203 \300A@!\202#\302\303!A\262\202,
@
B\262

A\262\202\211\237\207\207" [hif-stringify nil error "No token to stringify"] 4 (#$ . 39038)])
#@85 Scan token list for `hif-token-concat' ('##') token and concatenate tokens.

(fn L)
(defalias 'hif-token-concatenation #[257 "\300
>\203\257\301\211\302\301\303\304\"\262@\211\262\203\254\300=\204*
B\262
A\262\202\301\262\302\262\211
A\262\242\262\203N\304=\203U\211
A\262\242\211\262\204U\305\306!\210\202]B\262\300\262\300=\203\241
T\262A\262@\262\304=\203}A\262@\262\203\207\300=\203\221\305\307\310 #\210\202]B\262A\262@\262\202]\300\237!
B\262
\202\211\237\207\207" [hif-token-concat nil 0 hif-keep-single hif-space error "No token before `##' to concatenate" "No token after the %d-th `##' to concatenate at line %d" line-number-at-pos] 9 (#$ . 39362)])
#@17 

(fn LIS ATOM)
(defalias 'hif-delimit #[514 "\300\301\302\"\303!\"\304!\244\207" [mapcan make-closure #[257 "\211\300D\207" [V0] 3 "\n\n(fn L)"] butlast last] 6 (#$ . 40087)])
#@92 Expand a macro call, replace ACTUAL-PARMS in the macro body.

(fn MACRO-NAME ACTUAL-PARMS)
(defalias 'hif-macro-supply-arguments #[514 "
\236\211\205\211A\205\211A@\301=\205\211AA\211\205\211@
\205$
A@\302\211\211\211\205\251\205\251\205\251@\303=\211\262\203CA\262G\262G\262V\203[\304\305\"\210\202kW\203k\211\204k\304\306\"\210\211A\262\242\211\262\203\232\307
\203\211\204\211\310\n\311\"\202\214	@#\262A\262	\202k\312\313!!\262\314\315!\316\"\207" [hide-ifdef-env hif-define-macro nil hif-etc error "Too few parameters for macro %S" "Too many parameters for macro %S" cl-substitute hif-delimit hif-comma flatten-tree hif-token-stringification hif-keep-single hif-token-concatenation hif-space] 14 (#$ . 40273)])
#@105 Invoke a macro by expanding it, reparse macro-body and finally invoke it.

(fn MACRO-NAME ACTUAL-PARMS)
(defalias 'hif-invoke #[514 "\301\302\"\"!\207" [hide-ifdef-evaluator hif-parse-exp hif-macro-supply-arguments] 7 (#$ . 41058)])
#@64 Return the expanded result of the scanned tokens.

(fn REGEXP)
(defalias 'hif-canonicalize-tokens #[257 "\212\302
!\210\303\304!\305\"\211\205\303\306\"\307\230\310\311`\312 \210`\"\203(\313
D\262

\2031\314
D\262
)\266\203)\207" [hif-ifxdef-regexp hif-simple-token-only re-search-forward match-string 0 string-match 2 "n" nil hif-tokenize hif-end-of-line hif-defined hif-not] 7 (#$ . 41301)])
#@150 Return a Lisp expression for its condition by scanning current buffer.
Do this when cursor is at the beginning of `regexp' (i.e. #ifX).

(fn REGEXP)
(defalias 'hif-canonicalize #[257 "\303\212\304
!\210\305\306!\307	\"\211\205\305\310\"\311\230\303\312`\313 \210`\"\203*\314
D\262

\2033\315
D\262
\316
!)\266\204*\207" [case-fold-search hif-ifxdef-regexp hif-simple-token-only nil re-search-forward match-string 0 string-match 2 "n" hif-tokenize hif-end-of-line hif-defined hif-not hif-parse-exp] 7 (#$ . 41711)])
#@53 Move to next #if..., or #ifndef, at point or after.
(defalias 'hif-find-any-ifX #[0 "\301d\302#\303 \210\207" [hif-ifx-regexp re-search-forward t beginning-of-line] 4 (#$ . 42241)])
#@74 Move to next #if..., #elif..., #else, or #endif, after the current line.
(defalias 'hif-find-next-relevant #[0 "\301\210\302d\303#\205
\304 \207" [hif-ifx-else-endif-regexp nil re-search-forward t beginning-of-line] 4 (#$ . 42430)])
#@69 Move to previous #if..., #else, or #endif, before the current line.
(defalias 'hif-find-previous-relevant #[0 "\301 \210\302e\303#\205
\301 \207" [hif-ifx-else-endif-regexp beginning-of-line re-search-backward t] 4 (#$ . 42672)])
(defalias 'hif-looking-at-ifX #[0 "\301!\207" [hif-ifx-regexp looking-at] 2])
(defalias 'hif-looking-at-endif #[0 "\301!\207" [hif-endif-regexp looking-at] 2])
(defalias 'hif-looking-at-else #[0 "\301!\207" [hif-else-regexp looking-at] 2])
(defalias 'hif-looking-at-elif #[0 "\301!\207" [hif-elif-regexp looking-at] 2])
#@76 If positioned at #ifX, #elif, or #else form, skip to corresponding #endif.
(defalias 'hif-ifdef-to-endif #[0 "\300 \210\301 \203\302 \210\302 \207\303 \203\302 \207\304 \203\302 \207\305 \203%\306\207\307\310!\207" [hif-find-next-relevant hif-looking-at-ifX hif-ifdef-to-endif hif-looking-at-elif hif-looking-at-else hif-looking-at-endif done error "Mismatched #ifdef #endif pair"] 2 (#$ . 43234)])
#@68 If positioned at #endif form, skip backward to corresponding #ifX.
(defalias 'hif-endif-to-ifdef #[0 "`\300 \210\211`U\203\301\302!\210\210\303 \203\304 \210\304 \207\305 \203\"\304 \207\306 \203*\304 \207\307 \2031\310\207\301\311!\207" [hif-find-previous-relevant error "Mismatched #ifdef #endif pair" hif-looking-at-endif hif-endif-to-ifdef hif-looking-at-elif hif-looking-at-else hif-looking-at-ifX done "Mismatched #endif"] 3 (#$ . 43646)])
#@118 Move point to beginning of line of the next ifdef-endif.
With argument, do this that many times.

(fn &optional ARG)
(defalias 'forward-ifdef #[256 "\211\204\300\262
\211\301W\203\302
[!\207\301
W\205<\211[\262
`\303 \204%\304 \210\303 \2031\305 \266\202\211b\210\306\307!\266\202\207" [1 0 backward-ifdef hif-looking-at-ifX hif-find-next-relevant hif-ifdef-to-endif error "No following #ifdef"] 4 (#$ . 44106) "p"])
#@114 Move point to beginning of the previous ifdef-endif.
With argument, do this that many times.

(fn &optional ARG)
(defalias 'backward-ifdef #[256 "\211\204\300\262
\211\301W\203\302
[!\207\301
W\205?\211S\262
\303 \210`\304 \204(\305 \210\304 \2034\306 \266\202\211b\210\307\310!\266\202\207" [1 0 forward-ifdef beginning-of-line hif-looking-at-endif hif-find-previous-relevant hif-endif-to-ifdef error "No previous #ifdef"] 4 (#$ . 44543) "p"])
#@55 Move point to beginning of nested ifdef or else-part.
(defalias 'down-ifdef #[0 "`\300 \210\301 \206\302 ?\205\211b\210\303\304!\207" [hif-find-next-relevant hif-looking-at-ifX hif-looking-at-else error "No following #ifdef"] 3 (#$ . 45007) nil])
#@58 Move point to beginning of enclosing ifdef or else-part.
(defalias 'up-ifdef #[0 "\300 \210`\301 \204\f\302 \210\301 \203\303 \210\211`U\205\304\305!\207" [beginning-of-line hif-looking-at-endif hif-find-previous-relevant hif-endif-to-ifdef error "No previous #ifdef"] 3 (#$ . 45264) nil])
#@119 Move to the beginning of the next #ifX, #else, or #endif.
With argument, do this that many times.

(fn &optional ARG)
(defalias 'next-ifdef #[256 "\211\204\300\262
\211\301W\203\302
[!\207\301
W\205-\211S\262
\303 \210l\203\304 \210\305\306!\210\202\207" [1 0 previous-ifdef hif-find-next-relevant beginning-of-line error "No following #ifdefs, #elses, or #endifs"] 3 (#$ . 45566) "p"])
#@123 Move to the beginning of the previous #ifX, #else, or #endif.
With argument, do this that many times.

(fn &optional ARG)
(defalias 'previous-ifdef #[256 "\211\204\300\262
\211\301W\203\302
[!\207\301
W\205.\211S\262
`\303 \210\211`U\203*\304\305!\210\210\202\207" [1 0 next-ifdef hif-find-previous-relevant error "No previous #ifdefs, #elses, or #endifs"] 4 (#$ . 45969) "p"])
#@38 

(fn START END &optional ELSE ELIF)
(defalias 'hif-make-range #[1026 "F\207" [] 8 (#$ . 46361)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put hif-make-range speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@14 

(fn RANGE)
(defalias 'hif-range-start #[257 "\211\300\234\207" [0] 3 (#$ . 46609)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put hif-range-start speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@14 

(fn RANGE)
(defalias 'hif-range-else #[257 "\211\300\234\207" [1] 3 (#$ . 46842)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put hif-range-else speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@14 

(fn RANGE)
(defalias 'hif-range-end #[257 "\211\300\234\207" [2] 3 (#$ . 47073)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put hif-range-end speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@14 

(fn RANGE)
(defalias 'hif-range-elif #[257 "\211\300\234\207" [3] 3 (#$ . 47302)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put hif-range-elif speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@86 Return a Range structure describing the current #if region.
Point is left unchanged.
(defalias 'hif-find-range #[0 "\212\300 \210`\301\211\211
\204=\211\204=\302 \210\303 \203\304 \210\202\305 \203,`C\244\262\202\306 \2037`\262\202`\262
\202
\203[\302 \210\303 \203O\304 \210\202A\306 \203X\307\310!\210`\262

F\266\210)\207" [beginning-of-line nil hif-find-next-relevant hif-looking-at-ifX hif-ifdef-to-endif hif-looking-at-elif hif-looking-at-else error "Found two elses in a row?  Broken!"] 12 (#$ . 47533)])
#@88 Hide the line containing POINT.
Does nothing if `hide-ifdef-lines' is nil.

(fn POINT)
(defalias 'hif-hide-line #[257 "\205\212\211b\210\301\302 \303 \210`\")\207" [hide-ifdef-lines hide-ifdef-region-internal line-beginning-position hif-end-of-line] 4 (#$ . 48079)])
(defvar hif-recurse-level 0)
#@113 Call `hide-ifdef-guts' after narrowing to end of START line and END line.

(fn START END &optional DONT-GO-EOL)
(defalias 'hif-recurse-on #[770 "\212\214b\210\211\204\f\301\210`}\210T\302 +\207" [hif-recurse-level nil hide-ifdef-guts] 5 (#$ . 48385)])
#@315 Called at #ifX expression, this hides those parts that should be hidden.
It uses the judgment of `hide-ifdef-evaluator'.  EXPAND-REINCLUSION is a flag
indicating that we should expand the #ifdef even if it should be hidden.
Refer to `hide-ifdef-expand-reinclusion-guard' for more details.

(fn EXPAND-REINCLUSION)
(defalias 'hif-possibly-hide #[257 "\304\305	!\306 \211\211\307\234\262
\310\304\311\211\312\234\262
!\210\211\204
\203$
\204\240\313\n!!\203\240\203[@\311\211\314\234\262
!\210\315\211\314\234\262
S\"\210
\240\210\211b\210A\262\305!\262\210\202\n
\211\316\234\262
\203\217\311\211\316\234\262
!\210\315\211\314\234\262
\211\316\234\262
S\"\210\317\211\316\234\262
\211\312\234\262
\"\210\202\232\315`\211\312\234\262
S\"\210\310\262
\202\n
\203\304@\311
!\210\315
\211\312\234\262
S\"\210\317\211\314\234\262
\"\266\202
\211\316\234\262
\203\370\311\211\316\234\262
!\210\315\211\316\234\262
\211\312\234\262
S\"\210\317\211\314\234\262
\211\316\234\262
\"\210\202
\317\211\314\234\262
\211\312\234\262
\"\210\310\262
\304\262\202\311\211\314\234\262
!\210\211\312\234\262
b\210\304)\207" [case-fold-search hif-ifx-regexp hide-ifdef-evaluator hif-elif-regexp nil hif-canonicalize hif-find-range 3 t hif-hide-line 2 hif-not 0 hide-ifdef-region 1 hif-recurse-on] 12 (#$ . 48650)])
#@18 

(fn START END)
(defalias 'hif-evaluate-region #[514 "\3011\f\302\"0\202\210\303\211\205\3041\305
!0\202\210\211
!\207" [hide-ifdef-evaluator (error) hif-tokenize nil (error) hif-parse-exp] 6 (#$ . 50004)])
#@34 

(fn NAME DEF &optional RESULT)
(defalias 'hif-display-macro #[770 "
\203\271
<\203\271
@\300=\203\271\301PA@\302AA@\262
\203E\303P\262
@\203@\304@!A\2056\305Q\262
A\262\202&\306P\262\307P\262\203\215<\203^@\262
A\262\202d\262
\302\262
9\203x\310!\311=\205t\307P\202\207
;\203\203\310!\202\207\312\313\"P\262\202J\203\264<\203\235@\300=\204\264\250\203\254\312\314\211#\202\261\312\315\"P\262\316\317\"\207\316\320#\207" [hif-define-macro "#define " nil "(" symbol-name "," ")" " " hif-stringify hif-comma format "%S" "\n=> %S (%#x)" "\n=> %S" message "%s" "%S <= `%s'"] 11 (#$ . 50230)])
#@547 Evaluate the macro expansion result for the active region.
If no region is currently active, find the current #ifdef/#define and evaluate
the result; otherwise it looks for current word at point.
Currently it supports only math calculations, strings or argumented macros can
not be expanded.
This function by default ignores parsing error and return `false' on evaluating
runtime C(++) statements or tokens that normal C(++) preprocessor can't perform;
however, when this command is prefixed, it will display the error instead.

(fn RSTART REND)
(defalias 'hif-evaluate-macro #[514 "\306\307!\210\310`\310\212\311 \204J\310\262\310\262\312 \210\313	\310\314#\203:\315!\315 U\203:\316\317!\320\230\203J\313\n\310\314#\210\202J
b\210\321\322!\262
\211@\262\211A\262\206O`\206W\323 \210`\310\314\3241e\325\"0\202g\210\310\211G\326X\203\222\211@\236\206y\211@\f\236\211\262\203\222\327
@!:?\211\262\203\222\327
@!\206\250\211\205\250\3301\241\331
!0\202\250
\205\246\211\262
\332!\3331\267/!0\202\300\334\335\315 $\262
G\336U\203\316\337\340\"\202z
G\326U\203=
\203(
\203\344\341\"\202z
\342!\203\373\211\203\373\211\247\203\373\337\343\211#\202z
\344!\203
\211\203
\211\247\203
\337\345#\202z
\3460\"\203!
\337\347\"\202z
\337\350\"\202z
\2036
\341A#\202z
\337\350\"\202z
\211\250\203_
\211\336U\204N
\211\326U\203V
\337\351#\202z
\337\352\211$\202z
\211\353\267\202u
\337\351\354#\202z
\337\351\355#\202z
\337\351#\262
\306\356!\210\266\207*\207" [case-fold-search hif-macro-expr-prefix-regexp hif-macroref-regexp hide-ifdef-env hif-predefine-alist current-prefix-arg run-hooks hide-ifdef-evalulate-enter-hook nil use-region-p beginning-of-line re-search-forward t line-number-at-pos match-string 2 "define" bounds-of-thing-at-point word hif-end-of-line (error) hif-tokenize 1 hif-lookup (error) hif-parse-exp hif-stringify (error) error "Error: line %d %S when evaluating `%s'" 0 message "`%s'" hif-display-macro hif-is-number "%S (%#x)" hif-is-float "%S (%s)" string-match "%s" "`%s' is not defined" "%S <= `%s'" "%S (%#x) <= `%s'" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 357 t 365)) false true hide-ifdef-evalulate-leave-hook hide-ifdef-evaluator hif-string-literal-regexp] 18 (#$ . 50889) (byte-code "\300 \204\301\207\302 \303 D\207" [use-region-p (nil nil) region-beginning region-end] 2)])
#@182 Parse argument list formatted as `( arg1 [ , argn] [...] )'.
The `...' is also included.  Return a list of the arguments, if `...' exists the
first arg will be `hif-etc'.

(fn STR)
(defalias 'hif-parse-macro-arglist #[257 "\301\302`GZ`\"A\301\211\211\211A\262\242\211\262\303=\2042\211\304\267\202*\305\262\202
\202
\211B\262\202
\203=\306\237B\202?
\237)\207" [hif-simple-token-only nil hif-tokenize hif-rparen #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (hif-etc 33 hif-comma 39)) t hif-etc] 7 (#$ . 53320)])
(defvar hif-verbose-define-count 0)
#@93 Parse texts and retrieve all defines within the region MIN and MAX.

(fn &optional MIN MAX)
(defalias 'hif-find-define #[512 "
\203
b\210\306\307#\205\350\310\311!\312\230\306	\307#\205\310\313!\310\314!\2030\315\316\317\310\311!!\"\2068\310\311!\2058\320C\203\321\n\203G\321\n\"\206\342`\322 \210`\320\205\203\fT
\203l\f\323\246\313U\203l\324\325\326`!\327!#\210\3301x\331\"0\202\203\210\307\332\333\334\335\"#\211\205\241\203\235\211<\203\235\211G\313U\203\235\336
!\206\241\337E\205\254\340!#\236\205\313\211\203\277\211\241\206\313\307\202\313\340!B#B\211#)\266\210\202\344
\203\341\341!\203\341\342\340!!\210\307\266\203\205\350\307\207" [hif-define-regexp hif-macroref-regexp hide-ifdef-exclude-define-regexp hif-simple-token-only hif-verbose-define-count hide-ifdef-verbose re-search-forward t match-string 2 "define" 1 3 delq hif-space hif-parse-macro-arglist nil string-match hif-end-of-line 50 message "[Line %d] defining %S" line-number-at-pos substring-no-properties (error) hif-tokenize replace-regexp-in-string "^[ 	]*\\|[ 	]*$" "" buffer-substring-no-properties hif-parse-exp hif-define-macro intern intern-soft hif-undefine-symbol hide-ifdef-env] 13 (#$ . 53931) nil])
#@78 Scan and add all #define macros between MIN and MAX.

(fn &optional MIN MAX)
(defalias 'hif-add-new-defines #[512 "\212\214\301\302d!\210\303\"\203\302d!\210`\262\202\211\203\"\211b\202$db*\207" [hif-verbose-define-count 0 forward-comment hif-find-define] 5 (#$ . 55184) nil])
#@112 Does most of the work of `hide-ifdefs'.
It does not do the work that's pointless to redo on a recursive entry.
(defalias 'hide-ifdef-guts #[0 "\212\305	\205\306 \205\307\n\306 \"\205\310U\311\211\311\310eb\210`\262\3121D\313 \262
\314\"\210\211\2038\315!\210`\262\211\204'\3110\202L\316\317\320 #\262
*\266\203)\207" [case-fold-search hide-ifdef-expand-reinclusion-guard hide-ifdef-header-regexp hif-recurse-level hif-__COUNTER__ t buffer-file-name string-match 0 nil (error) hif-find-any-ifX hif-add-new-defines hif-possibly-hide error "Error: failed at line %d %S" line-number-at-pos] 9 (#$ . 55478)])
#@32 Toggle `hide-ifdef-read-only'.
(defalias 'hide-ifdef-toggle-read-only #[0 "?\304\305\203
\306\202\307\"\210	\203\206\n\310 \207" [hide-ifdef-read-only hide-ifdef-hiding hif-outside-read-only buffer-read-only message "Hide-Read-Only %s" "ON" "OFF" force-mode-line-update] 3 (#$ . 56108) nil])
#@58 Replacement for `read-only-mode' within Hide-Ifdef mode.
(defalias 'hide-ifdef-toggle-outside-read-only #[0 "?\304\305\203
\306\202\307\"\210	\203\n\206\310 \207" [hif-outside-read-only hide-ifdef-hiding hide-ifdef-read-only buffer-read-only message "Read only %s" "ON" "OFF" force-mode-line-update] 3 (#$ . 56418) nil])
#@19 Toggle shadowing.
(defalias 'hide-ifdef-toggle-shadowing #[0 "\301\300!\210?\302\303\203\304\202\305\"\210\214~\210\306ed\"\211\205N\211@\307
\310\"\203G\203;\311
\312\313#\210\311
\314\300#\210\202G\311
\314\313#\210\311
\312\310#\210
A\266\202\202\262
)\207" [hide-ifdef-shadow make-local-variable message "Shadowing %s" "ON" "OFF" overlays-in overlay-get hide-ifdef overlay-put invisible nil face] 6 (#$ . 56757) nil])
#@115 Define a VAR to VAL (default 1) in `hide-ifdef-env'.
This allows #ifdef VAR to be hidden.

(fn VAR &optional VAL)
(defalias 'hide-ifdef-define #[513 "\301\206\302\"\210\203\303 \210\304\305\206\302#\207" [hide-ifdef-hiding hif-set-var 1 hide-ifdefs message "%s set to %s"] 6 (#$ . 57200) (byte-code "\212\301 \210\302!\203\303\304!\210\305\306!\202\307)\310\311\"\312\313\314\"\307\211\315\307\316&

D\207" [hif-ifx-else-endif-regexp beginning-of-line looking-at forward-word-strictly 2 current-word strict nil read-minibuffer "Define what? " read-from-minibuffer format "Set %s to? (default 1): " t "1"] 9)])
#@12 

(fn VAR)
(defalias 'hif-undefine-symbol #[257 "\211\236\205\302
\236\"\211	\236\204\303\304!\305\"\210\306\207" [hide-ifdef-env hif-predefine-alist delete unintern symbol-name nil t] 4 (#$ . 57835)])
#@74 Undefine a VAR so that #ifdef VAR would not be included.

(fn START END)
(defalias 'hide-ifdef-undef #[514 "\301!\203\301
!\203\302\"\206\303\304\305 \"\211\205\306
!\307
!\310U\203,\311\312\"\207\313
!\210\2037\314 \210\311\315\"\207" [hide-ifdef-hiding number-or-marker-p buffer-substring-no-properties read-string "Undefine what? " current-word intern hif-defined 0 message "`%s' not defined, no need to undefine it" hif-undefine-symbol hide-ifdefs "`%S' undefined"] 7 (#$ . 58052) (byte-code "\300 \203\301 \302 D\207\303\207" [use-region-p region-beginning region-end (nil nil)] 2)])
#@451 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.
With prefix command presents it will also hide the #ifdefs themselves.

Hiding will only be performed within the marked region if there is one.

Turn off hiding by calling `show-ifdefs'.

(fn &optional START END NOMSG)
(defalias 'hide-ifdefs #[768 "\206	\214	\n\211\205
\206\306 ?\307 \n\203 \310\311!\210
\204*\305\312!\210\2032\313 \210\314\206:e\206?d}\210\315 \210\206J\f\n\205Y\310\316\317\320\307 \"!\"*\266\202)\207" [hide-ifdef-lines current-prefix-arg hide-ifdef-verbose buffer-read-only hif-outside-read-only hide-ifdef-mode use-region-p current-time message "Hiding..." 1 show-ifdefs t hide-ifdef-guts "Hiding done, %.1f seconds elapsed" float-time time-subtract hide-ifdef-hiding hide-ifdef-read-only] 11 (#$ . 58666) (byte-code "\300 \203\301 \302 D\207edD\207" [use-region-p region-beginning region-end] 2)])
#@97 Cancel the effects of `hide-ifdef': show the contents of all #ifdefs.

(fn &optional START END)
(defalias 'show-ifdefs #[512 "\303\206e\206
d\"\210\304\211\207" [hif-outside-read-only buffer-read-only hide-ifdef-hiding hif-show-all nil] 5 (#$ . 59757) (byte-code "\300 \203\301 \302 D\207edD\207" [use-region-p region-beginning region-end] 2)])
#@91 Utility to hide and show ifdef block.
Return as (TOP . BOTTOM) the extent of ifdef block.
(defalias 'hif-find-ifdef-block #[0 "\300\212\301 \210\302 \204\303 \204\304 \210`\305 \210`S\262)\212\301 \210\306 \204'\307 \210\303 \2035\305 \210\307 \210\202'
`S^)B\207" [nil beginning-of-line hif-looking-at-else hif-looking-at-ifX up-ifdef hif-ifdef-to-endif hif-looking-at-endif hif-find-next-relevant] 4 (#$ . 60118)])
#@174 Hide the ifdef block (true or false part) enclosing or before the cursor.
With optional prefix argument ARG, also hide the #ifdefs themselves.

(fn &optional ARG START END)
(defalias 'hide-ifdef-block #[768 "\306 \203	T\307\310#\210\311\211)\202C\204\303\312!\210\313 \314
@A\"\210\2037\315
@!\210\315
AT!\210\310\210
\206@\211)\207" [hide-ifdef-lines hif-recurse-level mark-active hide-ifdef-mode hide-ifdef-hiding hide-ifdef-read-only use-region-p hif-recurse-on t nil 1 hif-find-ifdef-block hide-ifdef-region hif-hide-line hif-outside-read-only buffer-read-only] 7 (#$ . 60550) "P\nr"])
#@101 Show the ifdef block (true or false part) enclosing or before the cursor.

(fn &optional START END)
(defalias 'show-ifdef-block #[512 "\302!\203-\302
!\203-\303\"\211\203(\211@\304
\305\"\203!\306
!\210
A\266\202\202\210\307\211\207\31017\311 0\2029\210\307\303e`S]d`T^\"\307\203n	\203e\312\212@b\210\313 )\212ATb\210\314 \210`)\"\210\202n\312@SA\"\262
\205s\211?\205\222
\211\205\220\211@\304
\305\"\203\211\306
!\210
A\266\202\202x\262
\207" [mark-active hide-ifdef-lines number-or-marker-p overlays-in overlay-get hide-ifdef delete-overlay nil (error) hif-find-ifdef-block hif-show-ifdef-region line-beginning-position hif-end-of-line] 10 (#$ . 61168) (byte-code "\300 \203\301 \302 D\207\303\207" [use-region-p region-beginning region-end (nil nil)] 2)])
#@50 A global assoc list of pre-defined symbol lists.
(defvar hide-ifdef-define-alist nil (#$ . 61961))
#@62 Set the association for NAME to `hide-ifdef-env'.

(fn NAME)
(defalias 'hide-ifdef-set-define-alist #[257 "\211B	B\211\207" [hide-ifdef-env hide-ifdef-define-alist] 3 (#$ . 62066) "SSet define list: "])
#@71 Set `hide-ifdef-env' to the define list specified by NAME.

(fn NAME)
(defalias 'hide-ifdef-use-define-alist #[257 "\211;\203\n\303
!\262
\304
\"\211\203\211A\202\305\306\"\210\n\205#\307 \207" [hide-ifdef-define-alist hide-ifdef-env hide-ifdef-hiding intern assoc error "No define list for %s" hide-ifdefs] 5 (#$ . 62277) (byte-code "\301\302\303\304\"\305\306$C\207" [hide-ifdef-define-alist completing-read "Use define list: " mapcar #[257 "\300
@!\207" [symbol-name] 3 "\n\n(fn X)"] nil t] 5)])
(provide 'hideif)