UNIFDEF(1)

💖 UNIFDEF(1) — like, the manual page, but make it make sense 💖

okay bestie, gather round, because this is the Programmer's Manual entry for unifdef (and its chaotic sibling unifdefall), and it is genuinely iconic. no cap. let's get into it. 🦋

---

✨ NAME ✨

unifdef, unifdefall — remove preprocessor conditionals from code. that's the whole job. it's giving surgical. 💅

---

✨ SYNOPSIS ✨

unifdef [-bBcdehKkmnsStV] [-Ipath] [-[i]Dsym[=val]] [-[i]Usym] ...
        [-f defile] [-x {012}] [-M backext] [-o outfile] [infile ...]
unifdefall [-Ipath] ... file

like look at all those flags. she's got range. 🎀

---

✨ DESCRIPTION ✨

so unifdef selectively processes conditional cpp(1) directives. it removes from a file both the directives and any additional text that they say should be removed — while otherwise leaving the file completely alone. lowkey respectful of your code. 🫶

unifdef acts on #if, #ifdef, #ifndef, #elif, #else, and #endif lines, using macros specified in -D and -U command line options or in -f definitions files. a directive gets processed if the macro specs are sufficient to give a definite value for its control expression.

• if the result is false, the directive and the following lines under its control are removed. bye. 💀
• if the result is true, only the directive itself is removed.
• an #ifdef or #ifndef directive gets passed through unchanged if its controlling macro isn't specified.
• any #if or #elif control expression that has an unknown value, or that unifdef can't parse, gets passed through unchanged.

by default, unifdef ignores #if and #elif lines with constant expressions — but you can tell it to process them by specifying the -k flag on the command line. 👑

---

🧠 the expression syntax, explained 🧠

it understands a commonly-used subset of the expression syntax for #if and #elif lines:

• integer constants
• integer values of macros defined on the command line
• the defined() operator
• the operators !, ~, - (unary), *, /, %, +, -, <, <=, >, >=, ==, !=, &, ^, |, &&, ||
• parenthesized expressions

division by zero is treated as an unknown value. no, it will not yell at you. it just... doesn't know. 🙈

a kind of “short circuit” evaluation is used for the && operator: if either operand is definitely false then the result is false, even if the value of the other operand is unknown. similarly, if either operand of || is definitely true then the result is true. it's doing the absolute most to be helpful. ✨

when evaluating an expression, unifdef does not expand macros first. the value of a macro must be a simple number, not an expression. a limited form of indirection is allowed, where one macro's value is the name of another. 🪆

---

🎭 object-like vs function-like macros 🎭

in most cases, unifdef does not distinguish between object-like macros (without arguments) and function-like macros (with arguments). a function-like macro invocation can appear in #if and #elif control expressions.

• if the macro isn't explicitly defined, or is defined with the -D flag on the command-line, or with #define in a -f definitions file, its arguments are ignored.
• if a macro is explicitly undefined on the command line with the -U flag, or with #undef in a -f definitions file, it may not have any arguments since this leads to a syntax error. ⚠️

---

🕵️ what it knows about C 🕵️

unifdef understands just enough about C to know when one of the directives is inactive because it's inside a comment, or can't be evaluated because it's split by a backslash-continued line. it spots unusually-formatted preprocessor directives and passes them through unchanged when the layout is too odd for it to handle. (see the “BUGS” section below.) it's not nosy, it's just observant. 🌸

---

🌈 unifdefall 🌈

a script called unifdefall can be used to remove all conditional cpp(1) directives from a file. it uses unifdef -s and cpp -dM to get lists of all the controlling macros and their definitions (or lack thereof), then invokes unifdef with appropriate arguments to process the file. she's a delegator. she's a project manager. 💅

---

✨ OPTIONS ✨

• -Dsym=val — specify that a macro is defined to a given value.
• -Dsym — specify that a macro is defined to the value 1.
• -Usym — specify that a macro is undefined.

if the same macro appears in more than one argument, the last occurrence dominates. last one wins, like always. 👑

• -iDsym[=val]
• -iUsym — C strings, comments, and line continuations are ignored within #ifdef and #ifndef blocks controlled by macros specified with these options.
• -f defile — the file defile contains #define and #undef preprocessor directives, which have the same effect as the corresponding -D and -U command-line arguments. you can have multiple -f arguments and mix them with -D and -U arguments; later options override earlier ones.

each directive must be on a single line. object-like macro definitions (without arguments) are set to the given value. function-like macro definitions (with arguments) are treated as if they are set to 1.

Warning: string literals and character constants are not parsed correctly in -f files. 😭

• -b — replace removed lines with blank lines instead of deleting them. mutually exclusive with the -B option.
• -B — compress blank lines around a deleted section. mutually exclusive with the -b option.
• -c — complement, i.e., lines that would have been removed or blanked are retained and vice versa. flip it. reverse it. 🔄
• -d — turn on printing of debugging messages.
• -e — by default, unifdef will report an error if it needs to remove a preprocessor directive that spans more than one line, for example, if it has a multi-line comment hanging off its right hand end. the -e flag makes it ignore the line instead.
• -h — print help.
• -I path — specifies to unifdefall an additional place to look for #include files. this option is ignored by unifdef for compatibility with cpp(1) and to simplify the implementation of unifdefall.
• -K — always treat the result of && and || operators as unknown if either operand is unknown, instead of short-circuiting when unknown operands can't affect the result. this option is for compatibility with older versions of unifdef.
• -k — process #if and #elif lines with constant expressions. by default, sections controlled by such lines are passed through unchanged because they typically start #if 0 and are used as a kind of comment to sketch out future or past development. it would be rude to strip them out, just as it would be for normal comments. 🥺
• -m — modify one or more input files in place. if an input file is not modified, the original is preserved instead of being overwritten with an identical copy.
• -M backext — modify input files in place, and keep backups of the original files by appending the backext to the input filenames. a zero length backext behaves the same as the -m option.
• -n — add #line directives to the output following any deleted lines, so that errors produced when compiling the output file correspond to line numbers in the input file.
• -o outfile — write output to the file outfile instead of the standard output when processing a single file.
• -s — instead of processing an input file as usual, this option causes unifdef to produce a list of macros that are used in preprocessor directive controlling expressions.
• -S — like the -s option, but the nesting depth of each macro is also printed. this is useful for working out the number of possible combinations of interdependent defined/undefined macros.
• -t — disables parsing for C strings, comments, and line continuations, which is useful for plain text. this is a blanket version of the -iD and -iU flags.
• -V — print version details.
• -x {012} — set exit status mode to zero, one, or two. see the “EXIT STATUS” section below for details.

---

unifdef takes its input from stdin if there are no file arguments. you must use the -m or -M options if there are multiple input files. you can specify input from stdin or output to stdout with -. 🎀

unifdef works nicely with the -Dsym option of diff(1). besties fr fr. 🫶

---

✨ EXIT STATUS ✨

in normal usage, unifdef's exit status depends on the mode set using the -x option.

• if the exit mode is zero (the default) then unifdef exits with status 0 if the output is an exact copy of the input, or with status 1 if the output differs.
• if the exit mode is one, unifdef exits with status 1 if the output is unmodified or 0 if it differs. yes it's inverted. it's quirky like that. 🙃
• if the exit mode is two, unifdef exits with status zero in both cases.

in all exit modes, unifdef exits with status 2 if there is an error. 💀

the exit status is 0 if the -h or -V command line options are given.

---

✨ DIAGNOSTICS ✨

the messages it can hit you with, verbatim, because these are iconic:

EOF in comment

Inappropriate #elif, #else or #endif

Missing macro name in #define or #undef

Obfuscated preprocessor control line

Premature EOF (with the line number of the most recent unterminated #if)

Too many levels of nesting

Unrecognized preprocessor directive

Unterminated char or string literal

---

✨ SEE ALSO ✨

cpp(1), diff(1)

the unifdef home page is http://dotat.at/prog/unifdef 🌈

---

✨ HISTORY ✨

the unifdef command appeared in 2.9BSD. ANSI C support was added in FreeBSD 4.7. she's a legacy. she's a veteran. she's been here. ⭐

---

✨ AUTHORS ✨

the original implementation was written by Dave Yost <Dave@Yost.com>. Tony Finch <dot@dotat.at> rewrote it to support ANSI C. two icons, one tool. 👑

---

✨ BUGS ✨

okay so here's the honest part, bestie. she's not perfect. nobody is.

• Expression evaluation is very limited.
• Character constants are not evaluated. String literals and character constants in -f definition files are ignored rather than parsed as part of a macro's replacement tokens.
• Only the basic form of C++ raw string literals is recognized, like R"(string)" without delimiters as in R"delimiter(string)delimiter".
• Source files are processed one line at a time, so preprocessor directives split across more than one physical line (because of comments or backslash-newline) cannot be handled in every situation.
• Trigraphs are not recognized.
• There is no support for macros with different definitions at different points in the source file.
• The text-mode and ignore functionality does not correspond to modern cpp(1) behaviour.

please send bug reports by email to ⟨dot@dotat.at⟩. she reads her inbox. 💖

---

and that's the whole page, bestie!! this was UNIFDEF(1) from the Programmer's Manual, dated December 3, 2015, and honestly? she ate. go forth and strip those conditionals. periodt. 💅✨🎀🦋🌸