;;; hideif.el --- hides selected code within ifdef -*- lexical-binding:t -*-
-;; Copyright (C) 1988, 1994, 2001-2015 Free Software Foundation, Inc.
+;; Copyright (C) 1988, 1994, 2001-2016 Free Software Foundation, Inc.
;; Author: Brian Marick
;; Daniel LaLiberte <liberte@holonexus.org>
(defcustom hide-ifdef-exclude-define-regexp nil
"Ignore #define names if those names match this exclusion pattern."
- :type 'string
+ :type '(choice (const nil) string)
:version "25.1")
(defcustom hide-ifdef-expand-reinclusion-protection t
:version "25.1")
(defcustom hide-ifdef-header-regexp
- "\\.h\\(h\\|xx\\|pp\\)?\\'"
+ "\\.h\\(h\\|xx\\|pp\\|\\+\\+\\)?\\'"
"C/C++ header file name patterns to determine if current buffer is a header.
Effective only if `hide-ifdef-expand-reinclusion-protection' is t."
:type 'string
(stringp id))))
(defun hif-define-operator (tokens)
- "`Upgrade' hif-define xxx to '(hif-define xxx)' so it won't be substituted."
+ "\"Upgrade\" hif-define XXX to `(hif-define XXX)' so it won't be substituted."
(let ((result nil)
(tok nil))
(while (setq tok (pop tokens))
(setq tok (cadr tokens))
(if (eq (car tokens) 'hif-lparen)
(if (and (hif-if-valid-identifier-p tok)
- (eq (cl-caddr tokens) 'hif-rparen))
+ (eq (nth 2 tokens) 'hif-rparen))
(setq tokens (cl-cdddr tokens))
(error "#define followed by non-identifier: %S" tok))
(setq tok (car tokens)
result))
;; Argument list is nil, direct expansion
(setq rep (hif-expand-token-list
- (cl-caddr rep) ; Macro's token list
+ (nth 2 rep) ; Macro's token list
tok expand_list))
;; Replace all remaining references immediately
(setq remains (cl-substitute tok rep remains))
(error "Error: unexpected token: %s" hif-token)))))
(defun hif-exprlist ()
- "Parse an exprlist: expr { ',' expr}."
+ "Parse an exprlist: expr { `,' expr}."
(let ((result (hif-expr)))
(if (eq hif-token 'hif-comma)
(let ((temp (list result)))
(defun hif-expr ()
"Parse an expression as found in #if.
-expr : or-expr | or-expr '?' expr ':' expr."
+expr : or-expr | or-expr `?' expr `:' expr."
(let ((result (hif-or-expr))
middle)
(while (eq hif-token 'hif-conditional)
result))
(defun hif-or-expr ()
- "Parse an or-expr : and-expr | or-expr '||' and-expr."
+ "Parse an or-expr : and-expr | or-expr `||' and-expr."
(let ((result (hif-and-expr)))
(while (eq hif-token 'hif-or)
(hif-nexttoken)
result))
(defun hif-and-expr ()
- "Parse an and-expr : logior-expr | and-expr '&&' logior-expr."
+ "Parse an and-expr : logior-expr | and-expr `&&' logior-expr."
(let ((result (hif-logior-expr)))
(while (eq hif-token 'hif-and)
(hif-nexttoken)
result))
(defun hif-logior-expr ()
- "Parse a logor-expr : logxor-expr | logor-expr '|' logxor-expr."
+ "Parse a logor-expr : logxor-expr | logor-expr `|' logxor-expr."
(let ((result (hif-logxor-expr)))
(while (eq hif-token 'hif-logior)
(hif-nexttoken)
result))
(defun hif-logxor-expr ()
- "Parse a logxor-expr : logand-expr | logxor-expr '^' logand-expr."
+ "Parse a logxor-expr : logand-expr | logxor-expr `^' logand-expr."
(let ((result (hif-logand-expr)))
(while (eq hif-token 'hif-logxor)
(hif-nexttoken)
result))
(defun hif-logand-expr ()
- "Parse a logand-expr : eq-expr | logand-expr '&' eq-expr."
+ "Parse a logand-expr : eq-expr | logand-expr `&' eq-expr."
(let ((result (hif-eq-expr)))
(while (eq hif-token 'hif-logand)
(hif-nexttoken)
(defun hif-math ()
"Parse an expression with + or -.
- math : muldiv | math '+|-' muldiv."
+ math : muldiv | math `+'|`-' muldiv."
(let ((result (hif-muldiv-expr))
(math-op nil))
(while (memq hif-token '(hif-plus hif-minus))
(defun hif-muldiv-expr ()
"Parse an expression with *,/,%.
- muldiv : factor | muldiv '*|/|%' factor."
+ muldiv : factor | muldiv `*'|`/'|`%' factor."
(let ((result (hif-factor))
(math-op nil))
(while (memq hif-token '(hif-multiply hif-divide hif-modulo))
(defun hif-factor ()
"Parse a factor.
-factor : '!' factor | '~' factor | '(' expr ')' | 'defined(' id ')' |
- 'id(parmlist)' | strings | id."
+factor : `!' factor | `~' factor | `(' expr `)' | `defined(' id `)' |
+ id `(' parmlist `)' | strings | id."
(cond
((eq hif-token 'hif-not)
(hif-nexttoken)
(defun hif-token-concat (a b)
"Concatenate two tokens into a longer token.
Currently support only simple token concatenation. Also support weird (but
-valid) token concatenation like '>' ## '>' becomes '>>'. Here we take care only
+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 '+='...)."
+can only be evaluated at C(++) runtime (like `++', `--' and `+='...)."
(if (or (memq a hif-valid-token-list)
(memq b hif-valid-token-list))
(let* ((ra (car (rassq a hif-token-alist)))
result))
(defun hif-evaluate-macro (rstart rend)
- "Evaluate the macro expansion result for a region.
+ "Evaluate the macro expansion result for the active region.
If no region active, find the current #ifdefs and evaluate the result.
Currently it supports only math calculations, strings or argumented macros can
not be expanded."
- (interactive "r")
+ (interactive
+ (if (use-region-p)
+ (list (region-beginning) (region-end))
+ '(nil nil)))
(let ((case-fold-search nil))
(save-excursion
- (unless mark-active
+ (unless (use-region-p)
(setq rstart nil rend nil)
(beginning-of-line)
(when (and (re-search-forward hif-macro-expr-prefix-regexp nil t)
result))))
(defun hif-parse-macro-arglist (str)
- "Parse argument list formatted as '( arg1 [ , argn] [...] )'.
-The '...' is also included. Return a list of the arguments, if '...' exists the
+ "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'."
(let* ((hif-simple-token-only nil) ; Dynamic binding var for `hif-tokenize'
(tokenlist
(let* ((default (save-excursion
(beginning-of-line)
(cond ((looking-at hif-ifx-else-endif-regexp)
- (forward-word 2)
+ (forward-word-strictly 2)
(current-word 'strict))
(t
nil))))
(defun hide-ifdef-undef (start end)
"Undefine a VAR so that #ifdef VAR would not be included."
- (interactive "r")
+ (interactive
+ (if (use-region-p)
+ (list (region-beginning) (region-end))
+ '(nil nil)))
(let* ((symstr
- (or (and mark-active
+ (or (and (number-or-marker-p start)
+ (number-or-marker-p end)
(buffer-substring-no-properties start end))
(read-string "Undefine what? " (current-word))))
(sym (and symstr
With optional prefix argument ARG, also hide the #ifdefs themselves."
(interactive "P\nr")
(let ((hide-ifdef-lines arg))
- (if mark-active
+ (if (use-region-p)
(let ((hif-recurse-level (1+ hif-recurse-level)))
(hif-recurse-on start end t)
(setq mark-active nil))
(defun show-ifdef-block (&optional start end)
"Show the ifdef block (true or false part) enclosing or before the cursor."
- (interactive "r")
- (if mark-active
+ (interactive
+ (if (use-region-p)
+ (list (region-beginning) (region-end))
+ '(nil nil)))
+ (if (and (number-or-marker-p start)
+ (number-or-marker-p end))
(progn
(dolist (o (overlays-in start end))
(if (overlay-get o 'hide-ifdef)