1/*
   2 * Copyright (c) 2002 - 2011 Tony Finch <dot@dotat.at>
   3 *
   4 * Redistribution and use in source and binary forms, with or without
   5 * modification, are permitted provided that the following conditions
   6 * are met:
   7 * 1. Redistributions of source code must retain the above copyright
   8 *    notice, this list of conditions and the following disclaimer.
   9 * 2. Redistributions in binary form must reproduce the above copyright
  10 *    notice, this list of conditions and the following disclaimer in the
  11 *    documentation and/or other materials provided with the distribution.
  12 *
  13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23 * SUCH DAMAGE.
  24 */
  25
  26/*
  27 * unifdef - remove ifdef'ed lines
  28 *
  29 * This code was derived from software contributed to Berkeley by Dave Yost.
  30 * It was rewritten to support ANSI C by Tony Finch. The original version
  31 * of unifdef carried the 4-clause BSD copyright licence. None of its code
  32 * remains in this version (though some of the names remain) so it now
  33 * carries a more liberal licence.
  34 *
  35 *  Wishlist:
  36 *      provide an option which will append the name of the
  37 *        appropriate symbol after #else's and #endif's
  38 *      provide an option which will check symbols after
  39 *        #else's and #endif's to see that they match their
  40 *        corresponding #ifdef or #ifndef
  41 *
  42 *   These require better buffer handling, which would also make
  43 *   it possible to handle all "dodgy" directives correctly.
  44 */
  45
  46#include <sys/types.h>
  47#include <sys/stat.h>
  48
  49#include <ctype.h>
  50#include <err.h>
  51#include <errno.h>
  52#include <stdarg.h>
  53#include <stdbool.h>
  54#include <stdio.h>
  55#include <stdlib.h>
  56#include <string.h>
  57#include <unistd.h>
  58
  59const char copyright[] =
  60    "@(#) $Version: unifdef-2.5 $\n"
  61    "@(#) $Author: Tony Finch (dot@dotat.at) $\n"
  62    "@(#) $URL: http://dotat.at/prog/unifdef $\n"
  63;
  64
  65/* types of input lines: */
  66typedef enum {
  67	LT_TRUEI,		/* a true #if with ignore flag */
  68	LT_FALSEI,		/* a false #if with ignore flag */
  69	LT_IF,			/* an unknown #if */
  70	LT_TRUE,		/* a true #if */
  71	LT_FALSE,		/* a false #if */
  72	LT_ELIF,		/* an unknown #elif */
  73	LT_ELTRUE,		/* a true #elif */
  74	LT_ELFALSE,		/* a false #elif */
  75	LT_ELSE,		/* #else */
  76	LT_ENDIF,		/* #endif */
  77	LT_DODGY,		/* flag: directive is not on one line */
  78	LT_DODGY_LAST = LT_DODGY + LT_ENDIF,
  79	LT_PLAIN,		/* ordinary line */
  80	LT_EOF,			/* end of file */
  81	LT_ERROR,		/* unevaluable #if */
  82	LT_COUNT
  83} Linetype;
  84
  85static char const * const linetype_name[] = {
  86	"TRUEI", "FALSEI", "IF", "TRUE", "FALSE",
  87	"ELIF", "ELTRUE", "ELFALSE", "ELSE", "ENDIF",
  88	"DODGY TRUEI", "DODGY FALSEI",
  89	"DODGY IF", "DODGY TRUE", "DODGY FALSE",
  90	"DODGY ELIF", "DODGY ELTRUE", "DODGY ELFALSE",
  91	"DODGY ELSE", "DODGY ENDIF",
  92	"PLAIN", "EOF", "ERROR"
  93};
  94
  95/* state of #if processing */
  96typedef enum {
  97	IS_OUTSIDE,
  98	IS_FALSE_PREFIX,	/* false #if followed by false #elifs */
  99	IS_TRUE_PREFIX,		/* first non-false #(el)if is true */
 100	IS_PASS_MIDDLE,		/* first non-false #(el)if is unknown */
 101	IS_FALSE_MIDDLE,	/* a false #elif after a pass state */
 102	IS_TRUE_MIDDLE,		/* a true #elif after a pass state */
 103	IS_PASS_ELSE,		/* an else after a pass state */
 104	IS_FALSE_ELSE,		/* an else after a true state */
 105	IS_TRUE_ELSE,		/* an else after only false states */
 106	IS_FALSE_TRAILER,	/* #elifs after a true are false */
 107	IS_COUNT
 108} Ifstate;
 109
 110static char const * const ifstate_name[] = {
 111	"OUTSIDE", "FALSE_PREFIX", "TRUE_PREFIX",
 112	"PASS_MIDDLE", "FALSE_MIDDLE", "TRUE_MIDDLE",
 113	"PASS_ELSE", "FALSE_ELSE", "TRUE_ELSE",
 114	"FALSE_TRAILER"
 115};
 116
 117/* state of comment parser */
 118typedef enum {
 119	NO_COMMENT = false,	/* outside a comment */
 120	C_COMMENT,		/* in a comment like this one */
 121	CXX_COMMENT,		/* between // and end of line */
 122	STARTING_COMMENT,	/* just after slash-backslash-newline */
 123	FINISHING_COMMENT,	/* star-backslash-newline in a C comment */
 124	CHAR_LITERAL,		/* inside '' */
 125	STRING_LITERAL		/* inside "" */
 126} Comment_state;
 127
 128static char const * const comment_name[] = {
 129	"NO", "C", "CXX", "STARTING", "FINISHING", "CHAR", "STRING"
 130};
 131
 132/* state of preprocessor line parser */
 133typedef enum {
 134	LS_START,		/* only space and comments on this line */
 135	LS_HASH,		/* only space, comments, and a hash */
 136	LS_DIRTY		/* this line can't be a preprocessor line */
 137} Line_state;
 138
 139static char const * const linestate_name[] = {
 140	"START", "HASH", "DIRTY"
 141};
 142
 143/*
 144 * Minimum translation limits from ISO/IEC 9899:1999 5.2.4.1
 145 */
 146#define	MAXDEPTH        64			/* maximum #if nesting */
 147#define	MAXLINE         4096			/* maximum length of line */
 148#define	MAXSYMS         4096			/* maximum number of symbols */
 149
 150/*
 151 * Sometimes when editing a keyword the replacement text is longer, so
 152 * we leave some space at the end of the tline buffer to accommodate this.
 153 */
 154#define	EDITSLOP        10
 155
 156/*
 157 * For temporary filenames
 158 */
 159#define TEMPLATE        "unifdef.XXXXXX"
 160
 161/*
 162 * Globals.
 163 */
 164
 165static bool             compblank;		/* -B: compress blank lines */
 166static bool             lnblank;		/* -b: blank deleted lines */
 167static bool             complement;		/* -c: do the complement */
 168static bool             debugging;		/* -d: debugging reports */
 169static bool             iocccok;		/* -e: fewer IOCCC errors */
 170static bool             strictlogic;		/* -K: keep ambiguous #ifs */
 171static bool             killconsts;		/* -k: eval constant #ifs */
 172static bool             lnnum;			/* -n: add #line directives */
 173static bool             symlist;		/* -s: output symbol list */
 174static bool             symdepth;		/* -S: output symbol depth */
 175static bool             text;			/* -t: this is a text file */
 176
 177static const char      *symname[MAXSYMS];	/* symbol name */
 178static const char      *value[MAXSYMS];		/* -Dsym=value */
 179static bool             ignore[MAXSYMS];	/* -iDsym or -iUsym */
 180static int              nsyms;			/* number of symbols */
 181
 182static FILE            *input;			/* input file pointer */
 183static const char      *filename;		/* input file name */
 184static int              linenum;		/* current line number */
 185static FILE            *output;			/* output file pointer */
 186static const char      *ofilename;		/* output file name */
 187static bool             overwriting;		/* output overwrites input */
 188static char             tempname[FILENAME_MAX];	/* used when overwriting */
 189
 190static char             tline[MAXLINE+EDITSLOP];/* input buffer plus space */
 191static char            *keyword;		/* used for editing #elif's */
 192
 193static const char      *newline;		/* input file format */
 194static const char       newline_unix[] = "\n";
 195static const char       newline_crlf[] = "\r\n";
 196
 197static Comment_state    incomment;		/* comment parser state */
 198static Line_state       linestate;		/* #if line parser state */
 199static Ifstate          ifstate[MAXDEPTH];	/* #if processor state */
 200static bool             ignoring[MAXDEPTH];	/* ignore comments state */
 201static int              stifline[MAXDEPTH];	/* start of current #if */
 202static int              depth;			/* current #if nesting */
 203static int              delcount;		/* count of deleted lines */
 204static unsigned         blankcount;		/* count of blank lines */
 205static unsigned         blankmax;		/* maximum recent blankcount */
 206static bool             constexpr;		/* constant #if expression */
 207static bool             zerosyms = true;	/* to format symdepth output */
 208static bool             firstsym;		/* ditto */
 209
 210static int              exitstat;		/* program exit status */
 211
 212static void             addsym(bool, bool, char *);
 213static void             closeout(void);
 214static void             debug(const char *, ...);
 215static void             done(void);
 216static void             error(const char *);
 217static int              findsym(const char *);
 218static void             flushline(bool);
 219static Linetype         parseline(void);
 220static Linetype         ifeval(const char **);
 221static void             ignoreoff(void);
 222static void             ignoreon(void);
 223static void             keywordedit(const char *);
 224static void             nest(void);
 225static void             process(void);
 226static const char      *skipargs(const char *);
 227static const char      *skipcomment(const char *);
 228static const char      *skipsym(const char *);
 229static void             state(Ifstate);
 230static int              strlcmp(const char *, const char *, size_t);
 231static void             unnest(void);
 232static void             usage(void);
 233static void             version(void);
 234
 235#define endsym(c) (!isalnum((unsigned char)c) && c != '_')
 236
 237/*
 238 * The main program.
 239 */
 240int
 241main(int argc, char *argv[])
 242{
 243	int opt;
 244
 245	while ((opt = getopt(argc, argv, "i:D:U:I:o:bBcdeKklnsStV")) != -1)
 246		switch (opt) {
 247		case 'i': /* treat stuff controlled by these symbols as text */
 248			/*
 249			 * For strict backwards-compatibility the U or D
 250			 * should be immediately after the -i but it doesn't
 251			 * matter much if we relax that requirement.
 252			 */
 253			opt = *optarg++;
 254			if (opt == 'D')
 255				addsym(true, true, optarg);
 256			else if (opt == 'U')
 257				addsym(true, false, optarg);
 258			else
 259				usage();
 260			break;
 261		case 'D': /* define a symbol */
 262			addsym(false, true, optarg);
 263			break;
 264		case 'U': /* undef a symbol */
 265			addsym(false, false, optarg);
 266			break;
 267		case 'I': /* no-op for compatibility with cpp */
 268			break;
 269		case 'b': /* blank deleted lines instead of omitting them */
 270		case 'l': /* backwards compatibility */
 271			lnblank = true;
 272			break;
 273		case 'B': /* compress blank lines around removed section */
 274			compblank = true;
 275			break;
 276		case 'c': /* treat -D as -U and vice versa */
 277			complement = true;
 278			break;
 279		case 'd':
 280			debugging = true;
 281			break;
 282		case 'e': /* fewer errors from dodgy lines */
 283			iocccok = true;
 284			break;
 285		case 'K': /* keep ambiguous #ifs */
 286			strictlogic = true;
 287			break;
 288		case 'k': /* process constant #ifs */
 289			killconsts = true;
 290			break;
 291		case 'n': /* add #line directive after deleted lines */
 292			lnnum = true;
 293			break;
 294		case 'o': /* output to a file */
 295			ofilename = optarg;
 296			break;
 297		case 's': /* only output list of symbols that control #ifs */
 298			symlist = true;
 299			break;
 300		case 'S': /* list symbols with their nesting depth */
 301			symlist = symdepth = true;
 302			break;
 303		case 't': /* don't parse C comments */
 304			text = true;
 305			break;
 306		case 'V': /* print version */
 307			version();
 308		default:
 309			usage();
 310		}
 311	argc -= optind;
 312	argv += optind;
 313	if (compblank && lnblank)
 314		errx(2, "-B and -b are mutually exclusive");
 315	if (argc > 1) {
 316		errx(2, "can only do one file");
 317	} else if (argc == 1 && strcmp(*argv, "-") != 0) {
 318		filename = *argv;
 319		input = fopen(filename, "rb");
 320		if (input == NULL)
 321			err(2, "can't open %s", filename);
 322	} else {
 323		filename = "[stdin]";
 324		input = stdin;
 325	}
 326	if (ofilename == NULL) {
 327		ofilename = "[stdout]";
 328		output = stdout;
 329	} else {
 330		struct stat ist, ost;
 331		if (stat(ofilename, &ost) == 0 &&
 332		    fstat(fileno(input), &ist) == 0)
 333			overwriting = (ist.st_dev == ost.st_dev
 334				    && ist.st_ino == ost.st_ino);
 335		if (overwriting) {
 336			const char *dirsep;
 337			int ofd;
 338
 339			dirsep = strrchr(ofilename, '/');
 340			if (dirsep != NULL)
 341				snprintf(tempname, sizeof(tempname),
 342				    "%.*s/" TEMPLATE,
 343				    (int)(dirsep - ofilename), ofilename);
 344			else
 345				snprintf(tempname, sizeof(tempname),
 346				    TEMPLATE);
 347			ofd = mkstemp(tempname);
 348			if (ofd != -1)
 349				output = fdopen(ofd, "wb+");
 350			if (output == NULL)
 351				err(2, "can't create temporary file");
 352			fchmod(ofd, ist.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO));
 353		} else {
 354			output = fopen(ofilename, "wb");
 355			if (output == NULL)
 356				err(2, "can't open %s", ofilename);
 357		}
 358	}
 359	process();
 360	abort(); /* bug */
 361}
 362
 363static void
 364version(void)
 365{
 366	const char *c = copyright;
 367	for (;;) {
 368		while (*++c != '$')
 369			if (*c == '\0')
 370				exit(0);
 371		while (*++c != '$')
 372			putc(*c, stderr);
 373		putc('\n', stderr);
 374	}
 375}
 376
 377static void
 378usage(void)
 379{
 380	fprintf(stderr, "usage: unifdef [-bBcdeKknsStV] [-Ipath]"
 381	    " [-Dsym[=val]] [-Usym] [-iDsym[=val]] [-iUsym] ... [file]\n");
 382	exit(2);
 383}
 384
 385/*
 386 * A state transition function alters the global #if processing state
 387 * in a particular way. The table below is indexed by the current
 388 * processing state and the type of the current line.
 389 *
 390 * Nesting is handled by keeping a stack of states; some transition
 391 * functions increase or decrease the depth. They also maintain the
 392 * ignore state on a stack. In some complicated cases they have to
 393 * alter the preprocessor directive, as follows.
 394 *
 395 * When we have processed a group that starts off with a known-false
 396 * #if/#elif sequence (which has therefore been deleted) followed by a
 397 * #elif that we don't understand and therefore must keep, we edit the
 398 * latter into a #if to keep the nesting correct. We use strncpy() to
 399 * overwrite the 4 byte token "elif" with "if  " without a '\0' byte.
 400 *
 401 * When we find a true #elif in a group, the following block will
 402 * always be kept and the rest of the sequence after the next #elif or
 403 * #else will be discarded. We edit the #elif into a #else and the
 404 * following directive to #endif since this has the desired behaviour.
 405 *
 406 * "Dodgy" directives are split across multiple lines, the most common
 407 * example being a multi-line comment hanging off the right of the
 408 * directive. We can handle them correctly only if there is no change
 409 * from printing to dropping (or vice versa) caused by that directive.
 410 * If the directive is the first of a group we have a choice between
 411 * failing with an error, or passing it through unchanged instead of
 412 * evaluating it. The latter is not the default to avoid questions from
 413 * users about unifdef unexpectedly leaving behind preprocessor directives.
 414 */
 415typedef void state_fn(void);
 416
 417/* report an error */
 418static void Eelif (void) { error("Inappropriate #elif"); }
 419static void Eelse (void) { error("Inappropriate #else"); }
 420static void Eendif(void) { error("Inappropriate #endif"); }
 421static void Eeof  (void) { error("Premature EOF"); }
 422static void Eioccc(void) { error("Obfuscated preprocessor control line"); }
 423/* plain line handling */
 424static void print (void) { flushline(true); }
 425static void drop  (void) { flushline(false); }
 426/* output lacks group's start line */
 427static void Strue (void) { drop();  ignoreoff(); state(IS_TRUE_PREFIX); }
 428static void Sfalse(void) { drop();  ignoreoff(); state(IS_FALSE_PREFIX); }
 429static void Selse (void) { drop();               state(IS_TRUE_ELSE); }
 430/* print/pass this block */
 431static void Pelif (void) { print(); ignoreoff(); state(IS_PASS_MIDDLE); }
 432static void Pelse (void) { print();              state(IS_PASS_ELSE); }
 433static void Pendif(void) { print(); unnest(); }
 434/* discard this block */
 435static void Dfalse(void) { drop();  ignoreoff(); state(IS_FALSE_TRAILER); }
 436static void Delif (void) { drop();  ignoreoff(); state(IS_FALSE_MIDDLE); }
 437static void Delse (void) { drop();               state(IS_FALSE_ELSE); }
 438static void Dendif(void) { drop();  unnest(); }
 439/* first line of group */
 440static void Fdrop (void) { nest();  Dfalse(); }
 441static void Fpass (void) { nest();  Pelif(); }
 442static void Ftrue (void) { nest();  Strue(); }
 443static void Ffalse(void) { nest();  Sfalse(); }
 444/* variable pedantry for obfuscated lines */
 445static void Oiffy (void) { if (!iocccok) Eioccc(); Fpass(); ignoreon(); }
 446static void Oif   (void) { if (!iocccok) Eioccc(); Fpass(); }
 447static void Oelif (void) { if (!iocccok) Eioccc(); Pelif(); }
 448/* ignore comments in this block */
 449static void Idrop (void) { Fdrop();  ignoreon(); }
 450static void Itrue (void) { Ftrue();  ignoreon(); }
 451static void Ifalse(void) { Ffalse(); ignoreon(); }
 452/* modify this line */
 453static void Mpass (void) { strncpy(keyword, "if  ", 4); Pelif(); }
 454static void Mtrue (void) { keywordedit("else");  state(IS_TRUE_MIDDLE); }
 455static void Melif (void) { keywordedit("endif"); state(IS_FALSE_TRAILER); }
 456static void Melse (void) { keywordedit("endif"); state(IS_FALSE_ELSE); }
 457
 458static state_fn * const trans_table[IS_COUNT][LT_COUNT] = {
 459/* IS_OUTSIDE */
 460{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Eelif, Eelif, Eelif, Eelse, Eendif,
 461  Oiffy, Oiffy, Fpass, Oif,   Oif,   Eelif, Eelif, Eelif, Eelse, Eendif,
 462  print, done,  abort },
 463/* IS_FALSE_PREFIX */
 464{ Idrop, Idrop, Fdrop, Fdrop, Fdrop, Mpass, Strue, Sfalse,Selse, Dendif,
 465  Idrop, Idrop, Fdrop, Fdrop, Fdrop, Mpass, Eioccc,Eioccc,Eioccc,Eioccc,
 466  drop,  Eeof,  abort },
 467/* IS_TRUE_PREFIX */
 468{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Dfalse,Dfalse,Dfalse,Delse, Dendif,
 469  Oiffy, Oiffy, Fpass, Oif,   Oif,   Eioccc,Eioccc,Eioccc,Eioccc,Eioccc,
 470  print, Eeof,  abort },
 471/* IS_PASS_MIDDLE */
 472{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Pelif, Mtrue, Delif, Pelse, Pendif,
 473  Oiffy, Oiffy, Fpass, Oif,   Oif,   Pelif, Oelif, Oelif, Pelse, Pendif,
 474  print, Eeof,  abort },
 475/* IS_FALSE_MIDDLE */
 476{ Idrop, Idrop, Fdrop, Fdrop, Fdrop, Pelif, Mtrue, Delif, Pelse, Pendif,
 477  Idrop, Idrop, Fdrop, Fdrop, Fdrop, Eioccc,Eioccc,Eioccc,Eioccc,Eioccc,
 478  drop,  Eeof,  abort },
 479/* IS_TRUE_MIDDLE */
 480{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Melif, Melif, Melif, Melse, Pendif,
 481  Oiffy, Oiffy, Fpass, Oif,   Oif,   Eioccc,Eioccc,Eioccc,Eioccc,Pendif,
 482  print, Eeof,  abort },
 483/* IS_PASS_ELSE */
 484{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Eelif, Eelif, Eelif, Eelse, Pendif,
 485  Oiffy, Oiffy, Fpass, Oif,   Oif,   Eelif, Eelif, Eelif, Eelse, Pendif,
 486  print, Eeof,  abort },
 487/* IS_FALSE_ELSE */
 488{ Idrop, Idrop, Fdrop, Fdrop, Fdrop, Eelif, Eelif, Eelif, Eelse, Dendif,
 489  Idrop, Idrop, Fdrop, Fdrop, Fdrop, Eelif, Eelif, Eelif, Eelse, Eioccc,
 490  drop,  Eeof,  abort },
 491/* IS_TRUE_ELSE */
 492{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Eelif, Eelif, Eelif, Eelse, Dendif,
 493  Oiffy, Oiffy, Fpass, Oif,   Oif,   Eelif, Eelif, Eelif, Eelse, Eioccc,
 494  print, Eeof,  abort },
 495/* IS_FALSE_TRAILER */
 496{ Idrop, Idrop, Fdrop, Fdrop, Fdrop, Dfalse,Dfalse,Dfalse,Delse, Dendif,
 497  Idrop, Idrop, Fdrop, Fdrop, Fdrop, Dfalse,Dfalse,Dfalse,Delse, Eioccc,
 498  drop,  Eeof,  abort }
 499/*TRUEI  FALSEI IF     TRUE   FALSE  ELIF   ELTRUE ELFALSE ELSE  ENDIF
 500  TRUEI  FALSEI IF     TRUE   FALSE  ELIF   ELTRUE ELFALSE ELSE  ENDIF (DODGY)
 501  PLAIN  EOF    ERROR */
 502};
 503
 504/*
 505 * State machine utility functions
 506 */
 507static void
 508ignoreoff(void)
 509{
 510	if (depth == 0)
 511		abort(); /* bug */
 512	ignoring[depth] = ignoring[depth-1];
 513}
 514static void
 515ignoreon(void)
 516{
 517	ignoring[depth] = true;
 518}
 519static void
 520keywordedit(const char *replacement)
 521{
 522	snprintf(keyword, tline + sizeof(tline) - keyword,
 523	    "%s%s", replacement, newline);
 524	print();
 525}
 526static void
 527nest(void)
 528{
 529	if (depth > MAXDEPTH-1)
 530		abort(); /* bug */
 531	if (depth == MAXDEPTH-1)
 532		error("Too many levels of nesting");
 533	depth += 1;
 534	stifline[depth] = linenum;
 535}
 536static void
 537unnest(void)
 538{
 539	if (depth == 0)
 540		abort(); /* bug */
 541	depth -= 1;
 542}
 543static void
 544state(Ifstate is)
 545{
 546	ifstate[depth] = is;
 547}
 548
 549/*
 550 * Write a line to the output or not, according to command line options.
 551 */
 552static void
 553flushline(bool keep)
 554{
 555	if (symlist)
 556		return;
 557	if (keep ^ complement) {
 558		bool blankline = tline[strspn(tline, " \t\r\n")] == '\0';
 559		if (blankline && compblank && blankcount != blankmax) {
 560			delcount += 1;
 561			blankcount += 1;
 562		} else {
 563			if (lnnum && delcount > 0)
 564				printf("#line %d%s", linenum, newline);
 565			fputs(tline, output);
 566			delcount = 0;
 567			blankmax = blankcount = blankline ? blankcount + 1 : 0;
 568		}
 569	} else {
 570		if (lnblank)
 571			fputs(newline, output);
 572		exitstat = 1;
 573		delcount += 1;
 574		blankcount = 0;
 575	}
 576	if (debugging)
 577		fflush(output);
 578}
 579
 580/*
 581 * The driver for the state machine.
 582 */
 583static void
 584process(void)
 585{
 586	/* When compressing blank lines, act as if the file
 587	   is preceded by a large number of blank lines. */
 588	blankmax = blankcount = 1000;
 589	for (;;) {
 590		Linetype lineval = parseline();
 591		trans_table[ifstate[depth]][lineval]();
 592		debug("process line %d %s -> %s depth %d",
 593		    linenum, linetype_name[lineval],
 594		    ifstate_name[ifstate[depth]], depth);
 595	}
 596}
 597
 598/*
 599 * Flush the output and handle errors.
 600 */
 601static void
 602closeout(void)
 603{
 604	if (symdepth && !zerosyms)
 605		printf("\n");
 606	if (fclose(output) == EOF) {
 607		warn("couldn't write to %s", ofilename);
 608		if (overwriting) {
 609			unlink(tempname);
 610			errx(2, "%s unchanged", filename);
 611		} else {
 612			exit(2);
 613		}
 614	}
 615}
 616
 617/*
 618 * Clean up and exit.
 619 */
 620static void
 621done(void)
 622{
 623	if (incomment)
 624		error("EOF in comment");
 625	closeout();
 626	if (overwriting && rename(tempname, ofilename) == -1) {
 627		warn("couldn't rename temporary file");
 628		unlink(tempname);
 629		errx(2, "%s unchanged", ofilename);
 630	}
 631	exit(exitstat);
 632}
 633
 634/*
 635 * Parse a line and determine its type. We keep the preprocessor line
 636 * parser state between calls in the global variable linestate, with
 637 * help from skipcomment().
 638 */
 639static Linetype
 640parseline(void)
 641{
 642	const char *cp;
 643	int cursym;
 644	int kwlen;
 645	Linetype retval;
 646	Comment_state wascomment;
 647
 648	linenum++;
 649	if (fgets(tline, MAXLINE, input) == NULL)
 650		return (LT_EOF);
 651	if (newline == NULL) {
 652		if (strrchr(tline, '\n') == strrchr(tline, '\r') + 1)
 653			newline = newline_crlf;
 654		else
 655			newline = newline_unix;
 656	}
 657	retval = LT_PLAIN;
 658	wascomment = incomment;
 659	cp = skipcomment(tline);
 660	if (linestate == LS_START) {
 661		if (*cp == '#') {
 662			linestate = LS_HASH;
 663			firstsym = true;
 664			cp = skipcomment(cp + 1);
 665		} else if (*cp != '\0')
 666			linestate = LS_DIRTY;
 667	}
 668	if (!incomment && linestate == LS_HASH) {
 669		keyword = tline + (cp - tline);
 670		cp = skipsym(cp);
 671		kwlen = cp - keyword;
 672		/* no way can we deal with a continuation inside a keyword */
 673		if (strncmp(cp, "\\\r\n", 3) == 0 ||
 674		    strncmp(cp, "\\\n", 2) == 0)
 675			Eioccc();
 676		if (strlcmp("ifdef", keyword, kwlen) == 0 ||
 677		    strlcmp("ifndef", keyword, kwlen) == 0) {
 678			cp = skipcomment(cp);
 679			if ((cursym = findsym(cp)) < 0)
 680				retval = LT_IF;
 681			else {
 682				retval = (keyword[2] == 'n')
 683				    ? LT_FALSE : LT_TRUE;
 684				if (value[cursym] == NULL)
 685					retval = (retval == LT_TRUE)
 686					    ? LT_FALSE : LT_TRUE;
 687				if (ignore[cursym])
 688					retval = (retval == LT_TRUE)
 689					    ? LT_TRUEI : LT_FALSEI;
 690			}
 691			cp = skipsym(cp);
 692		} else if (strlcmp("if", keyword, kwlen) == 0)
 693			retval = ifeval(&cp);
 694		else if (strlcmp("elif", keyword, kwlen) == 0)
 695			retval = ifeval(&cp) - LT_IF + LT_ELIF;
 696		else if (strlcmp("else", keyword, kwlen) == 0)
 697			retval = LT_ELSE;
 698		else if (strlcmp("endif", keyword, kwlen) == 0)
 699			retval = LT_ENDIF;
 700		else {
 701			linestate = LS_DIRTY;
 702			retval = LT_PLAIN;
 703		}
 704		cp = skipcomment(cp);
 705		if (*cp != '\0') {
 706			linestate = LS_DIRTY;
 707			if (retval == LT_TRUE || retval == LT_FALSE ||
 708			    retval == LT_TRUEI || retval == LT_FALSEI)
 709				retval = LT_IF;
 710			if (retval == LT_ELTRUE || retval == LT_ELFALSE)
 711				retval = LT_ELIF;
 712		}
 713		if (retval != LT_PLAIN && (wascomment || incomment)) {
 714			retval += LT_DODGY;
 715			if (incomment)
 716				linestate = LS_DIRTY;
 717		}
 718		/* skipcomment normally changes the state, except
 719		   if the last line of the file lacks a newline, or
 720		   if there is too much whitespace in a directive */
 721		if (linestate == LS_HASH) {
 722			size_t len = cp - tline;
 723			if (fgets(tline + len, MAXLINE - len, input) == NULL) {
 724				/* append the missing newline */
 725				strcpy(tline + len, newline);
 726				cp += strlen(newline);
 727				linestate = LS_START;
 728			} else {
 729				linestate = LS_DIRTY;
 730			}
 731		}
 732	}
 733	if (linestate == LS_DIRTY) {
 734		while (*cp != '\0')
 735			cp = skipcomment(cp + 1);
 736	}
 737	debug("parser line %d state %s comment %s line", linenum,
 738	    comment_name[incomment], linestate_name[linestate]);
 739	return (retval);
 740}
 741
 742/*
 743 * These are the binary operators that are supported by the expression
 744 * evaluator.
 745 */
 746static Linetype op_strict(int *p, int v, Linetype at, Linetype bt) {
 747	if(at == LT_IF || bt == LT_IF) return (LT_IF);
 748	return (*p = v, v ? LT_TRUE : LT_FALSE);
 749}
 750static Linetype op_lt(int *p, Linetype at, int a, Linetype bt, int b) {
 751	return op_strict(p, a < b, at, bt);
 752}
 753static Linetype op_gt(int *p, Linetype at, int a, Linetype bt, int b) {
 754	return op_strict(p, a > b, at, bt);
 755}
 756static Linetype op_le(int *p, Linetype at, int a, Linetype bt, int b) {
 757	return op_strict(p, a <= b, at, bt);
 758}
 759static Linetype op_ge(int *p, Linetype at, int a, Linetype bt, int b) {
 760	return op_strict(p, a >= b, at, bt);
 761}
 762static Linetype op_eq(int *p, Linetype at, int a, Linetype bt, int b) {
 763	return op_strict(p, a == b, at, bt);
 764}
 765static Linetype op_ne(int *p, Linetype at, int a, Linetype bt, int b) {
 766	return op_strict(p, a != b, at, bt);
 767}
 768static Linetype op_or(int *p, Linetype at, int a, Linetype bt, int b) {
 769	if (!strictlogic && (at == LT_TRUE || bt == LT_TRUE))
 770		return (*p = 1, LT_TRUE);
 771	return op_strict(p, a || b, at, bt);
 772}
 773static Linetype op_and(int *p, Linetype at, int a, Linetype bt, int b) {
 774	if (!strictlogic && (at == LT_FALSE || bt == LT_FALSE))
 775		return (*p = 0, LT_FALSE);
 776	return op_strict(p, a && b, at, bt);
 777}
 778
 779/*
 780 * An evaluation function takes three arguments, as follows: (1) a pointer to
 781 * an element of the precedence table which lists the operators at the current
 782 * level of precedence; (2) a pointer to an integer which will receive the
 783 * value of the expression; and (3) a pointer to a char* that points to the
 784 * expression to be evaluated and that is updated to the end of the expression
 785 * when evaluation is complete. The function returns LT_FALSE if the value of
 786 * the expression is zero, LT_TRUE if it is non-zero, LT_IF if the expression
 787 * depends on an unknown symbol, or LT_ERROR if there is a parse failure.
 788 */
 789struct ops;
 790
 791typedef Linetype eval_fn(const struct ops *, int *, const char **);
 792
 793static eval_fn eval_table, eval_unary;
 794
 795/*
 796 * The precedence table. Expressions involving binary operators are evaluated
 797 * in a table-driven way by eval_table. When it evaluates a subexpression it
 798 * calls the inner function with its first argument pointing to the next
 799 * element of the table. Innermost expressions have special non-table-driven
 800 * handling.
 801 */
 802static const struct ops {
 803	eval_fn *inner;
 804	struct op {
 805		const char *str;
 806		Linetype (*fn)(int *, Linetype, int, Linetype, int);
 807	} op[5];
 808} eval_ops[] = {
 809	{ eval_table, { { "||", op_or } } },
 810	{ eval_table, { { "&&", op_and } } },
 811	{ eval_table, { { "==", op_eq },
 812			{ "!=", op_ne } } },
 813	{ eval_unary, { { "<=", op_le },
 814			{ ">=", op_ge },
 815			{ "<", op_lt },
 816			{ ">", op_gt } } }
 817};
 818
 819/*
 820 * Function for evaluating the innermost parts of expressions,
 821 * viz. !expr (expr) number defined(symbol) symbol
 822 * We reset the constexpr flag in the last two cases.
 823 */
 824static Linetype
 825eval_unary(const struct ops *ops, int *valp, const char **cpp)
 826{
 827	const char *cp;
 828	char *ep;
 829	int sym;
 830	bool defparen;
 831	Linetype lt;
 832
 833	cp = skipcomment(*cpp);
 834	if (*cp == '!') {
 835		debug("eval%d !", ops - eval_ops);
 836		cp++;
 837		lt = eval_unary(ops, valp, &cp);
 838		if (lt == LT_ERROR)
 839			return (LT_ERROR);
 840		if (lt != LT_IF) {
 841			*valp = !*valp;
 842			lt = *valp ? LT_TRUE : LT_FALSE;
 843		}
 844	} else if (*cp == '(') {
 845		cp++;
 846		debug("eval%d (", ops - eval_ops);
 847		lt = eval_table(eval_ops, valp, &cp);
 848		if (lt == LT_ERROR)
 849			return (LT_ERROR);
 850		cp = skipcomment(cp);
 851		if (*cp++ != ')')
 852			return (LT_ERROR);
 853	} else if (isdigit((unsigned char)*cp)) {
 854		debug("eval%d number", ops - eval_ops);
 855		*valp = strtol(cp, &ep, 0);
 856		if (ep == cp)
 857			return (LT_ERROR);
 858		lt = *valp ? LT_TRUE : LT_FALSE;
 859		cp = skipsym(cp);
 860	} else if (strncmp(cp, "defined", 7) == 0 && endsym(cp[7])) {
 861		cp = skipcomment(cp+7);
 862		debug("eval%d defined", ops - eval_ops);
 863		if (*cp == '(') {
 864			cp = skipcomment(cp+1);
 865			defparen = true;
 866		} else {
 867			defparen = false;
 868		}
 869		sym = findsym(cp);
 870		if (sym < 0) {
 871			lt = LT_IF;
 872		} else {
 873			*valp = (value[sym] != NULL);
 874			lt = *valp ? LT_TRUE : LT_FALSE;
 875		}
 876		cp = skipsym(cp);
 877		cp = skipcomment(cp);
 878		if (defparen && *cp++ != ')')
 879			return (LT_ERROR);
 880		constexpr = false;
 881	} else if (!endsym(*cp)) {
 882		debug("eval%d symbol", ops - eval_ops);
 883		sym = findsym(cp);
 884		cp = skipsym(cp);
 885		if (sym < 0) {
 886			lt = LT_IF;
 887			cp = skipargs(cp);
 888		} else if (value[sym] == NULL) {
 889			*valp = 0;
 890			lt = LT_FALSE;
 891		} else {
 892			*valp = strtol(value[sym], &ep, 0);
 893			if (*ep != '\0' || ep == value[sym])
 894				return (LT_ERROR);
 895			lt = *valp ? LT_TRUE : LT_FALSE;
 896			cp = skipargs(cp);
 897		}
 898		constexpr = false;
 899	} else {
 900		debug("eval%d bad expr", ops - eval_ops);
 901		return (LT_ERROR);
 902	}
 903
 904	*cpp = cp;
 905	debug("eval%d = %d", ops - eval_ops, *valp);
 906	return (lt);
 907}
 908
 909/*
 910 * Table-driven evaluation of binary operators.
 911 */
 912static Linetype
 913eval_table(const struct ops *ops, int *valp, const char **cpp)
 914{
 915	const struct op *op;
 916	const char *cp;
 917	int val;
 918	Linetype lt, rt;
 919
 920	debug("eval%d", ops - eval_ops);
 921	cp = *cpp;
 922	lt = ops->inner(ops+1, valp, &cp);
 923	if (lt == LT_ERROR)
 924		return (LT_ERROR);
 925	for (;;) {
 926		cp = skipcomment(cp);
 927		for (op = ops->op; op->str != NULL; op++)
 928			if (strncmp(cp, op->str, strlen(op->str)) == 0)
 929				break;
 930		if (op->str == NULL)
 931			break;
 932		cp += strlen(op->str);
 933		debug("eval%d %s", ops - eval_ops, op->str);
 934		rt = ops->inner(ops+1, &val, &cp);
 935		if (rt == LT_ERROR)
 936			return (LT_ERROR);
 937		lt = op->fn(valp, lt, *valp, rt, val);
 938	}
 939
 940	*cpp = cp;
 941	debug("eval%d = %d", ops - eval_ops, *valp);
 942	debug("eval%d lt = %s", ops - eval_ops, linetype_name[lt]);
 943	return (lt);
 944}
 945
 946/*
 947 * Evaluate the expression on a #if or #elif line. If we can work out
 948 * the result we return LT_TRUE or LT_FALSE accordingly, otherwise we
 949 * return just a generic LT_IF.
 950 */
 951static Linetype
 952ifeval(const char **cpp)
 953{
 954	int ret;
 955	int val = 0;
 956
 957	debug("eval %s", *cpp);
 958	constexpr = killconsts ? false : true;
 959	ret = eval_table(eval_ops, &val, cpp);
 960	debug("eval = %d", val);
 961	return (constexpr ? LT_IF : ret == LT_ERROR ? LT_IF : ret);
 962}
 963
 964/*
 965 * Skip over comments, strings, and character literals and stop at the
 966 * next character position that is not whitespace. Between calls we keep
 967 * the comment state in the global variable incomment, and we also adjust
 968 * the global variable linestate when we see a newline.
 969 * XXX: doesn't cope with the buffer splitting inside a state transition.
 970 */
 971static const char *
 972skipcomment(const char *cp)
 973{
 974	if (text || ignoring[depth]) {
 975		for (; isspace((unsigned char)*cp); cp++)
 976			if (*cp == '\n')
 977				linestate = LS_START;
 978		return (cp);
 979	}
 980	while (*cp != '\0')
 981		/* don't reset to LS_START after a line continuation */
 982		if (strncmp(cp, "\\\r\n", 3) == 0)
 983			cp += 3;
 984		else if (strncmp(cp, "\\\n", 2) == 0)
 985			cp += 2;
 986		else switch (incomment) {
 987		case NO_COMMENT:
 988			if (strncmp(cp, "/\\\r\n", 4) == 0) {
 989				incomment = STARTING_COMMENT;
 990				cp += 4;
 991			} else if (strncmp(cp, "/\\\n", 3) == 0) {
 992				incomment = STARTING_COMMENT;
 993				cp += 3;
 994			} else if (strncmp(cp, "/*", 2) == 0) {
 995				incomment = C_COMMENT;
 996				cp += 2;
 997			} else if (strncmp(cp, "//", 2) == 0) {
 998				incomment = CXX_COMMENT;
 999				cp += 2;
1000			} else if (strncmp(cp, "\'", 1) == 0) {
1001				incomment = CHAR_LITERAL;
1002				linestate = LS_DIRTY;
1003				cp += 1;
1004			} else if (strncmp(cp, "\"", 1) == 0) {
1005				incomment = STRING_LITERAL;
1006				linestate = LS_DIRTY;
1007				cp += 1;
1008			} else if (strncmp(cp, "\n", 1) == 0) {
1009				linestate = LS_START;
1010				cp += 1;
1011			} else if (strchr(" \r\t", *cp) != NULL) {
1012				cp += 1;
1013			} else
1014				return (cp);
1015			continue;
1016		case CXX_COMMENT:
1017			if (strncmp(cp, "\n", 1) == 0) {
1018				incomment = NO_COMMENT;
1019				linestate = LS_START;
1020			}
1021			cp += 1;
1022			continue;
1023		case CHAR_LITERAL:
1024		case STRING_LITERAL:
1025			if ((incomment == CHAR_LITERAL && cp[0] == '\'') ||
1026			    (incomment == STRING_LITERAL && cp[0] == '\"')) {
1027				incomment = NO_COMMENT;
1028				cp += 1;
1029			} else if (cp[0] == '\\') {
1030				if (cp[1] == '\0')
1031					cp += 1;
1032				else
1033					cp += 2;
1034			} else if (strncmp(cp, "\n", 1) == 0) {
1035				if (incomment == CHAR_LITERAL)
1036					error("unterminated char literal");
1037				else
1038					error("unterminated string literal");
1039			} else
1040				cp += 1;
1041			continue;
1042		case C_COMMENT:
1043			if (strncmp(cp, "*\\\r\n", 4) == 0) {
1044				incomment = FINISHING_COMMENT;
1045				cp += 4;
1046			} else if (strncmp(cp, "*\\\n", 3) == 0) {
1047				incomment = FINISHING_COMMENT;
1048				cp += 3;
1049			} else if (strncmp(cp, "*/", 2) == 0) {
1050				incomment = NO_COMMENT;
1051				cp += 2;
1052			} else
1053				cp += 1;
1054			continue;
1055		case STARTING_COMMENT:
1056			if (*cp == '*') {
1057				incomment = C_COMMENT;
1058				cp += 1;
1059			} else if (*cp == '/') {
1060				incomment = CXX_COMMENT;
1061				cp += 1;
1062			} else {
1063				incomment = NO_COMMENT;
1064				linestate = LS_DIRTY;
1065			}
1066			continue;
1067		case FINISHING_COMMENT:
1068			if (*cp == '/') {
1069				incomment = NO_COMMENT;
1070				cp += 1;
1071			} else
1072				incomment = C_COMMENT;
1073			continue;
1074		default:
1075			abort(); /* bug */
1076		}
1077	return (cp);
1078}
1079
1080/*
1081 * Skip macro arguments.
1082 */
1083static const char *
1084skipargs(const char *cp)
1085{
1086	const char *ocp = cp;
1087	int level = 0;
1088	cp = skipcomment(cp);
1089	if (*cp != '(')
1090		return (cp);
1091	do {
1092		if (*cp == '(')
1093			level++;
1094		if (*cp == ')')
1095			level--;
1096		cp = skipcomment(cp+1);
1097	} while (level != 0 && *cp != '\0');
1098	if (level == 0)
1099		return (cp);
1100	else
1101	/* Rewind and re-detect the syntax error later. */
1102		return (ocp);
1103}
1104
1105/*
1106 * Skip over an identifier.
1107 */
1108static const char *
1109skipsym(const char *cp)
1110{
1111	while (!endsym(*cp))
1112		++cp;
1113	return (cp);
1114}
1115
1116/*
1117 * Look for the symbol in the symbol table. If it is found, we return
1118 * the symbol table index, else we return -1.
1119 */
1120static int
1121findsym(const char *str)
1122{
1123	const char *cp;
1124	int symind;
1125
1126	cp = skipsym(str);
1127	if (cp == str)
1128		return (-1);
1129	if (symlist) {
1130		if (symdepth && firstsym)
1131			printf("%s%3d", zerosyms ? "" : "\n", depth);
1132		firstsym = zerosyms = false;
1133		printf("%s%.*s%s",
1134		    symdepth ? " " : "",
1135		    (int)(cp-str), str,
1136		    symdepth ? "" : "\n");
1137		/* we don't care about the value of the symbol */
1138		return (0);
1139	}
1140	for (symind = 0; symind < nsyms; ++symind) {
1141		if (strlcmp(symname[symind], str, cp-str) == 0) {
1142			debug("findsym %s %s", symname[symind],
1143			    value[symind] ? value[symind] : "");
1144			return (symind);
1145		}
1146	}
1147	return (-1);
1148}
1149
1150/*
1151 * Add a symbol to the symbol table.
1152 */
1153static void
1154addsym(bool ignorethis, bool definethis, char *sym)
1155{
1156	int symind;
1157	char *val;
1158
1159	symind = findsym(sym);
1160	if (symind < 0) {
1161		if (nsyms >= MAXSYMS)
1162			errx(2, "too many symbols");
1163		symind = nsyms++;
1164	}
1165	symname[symind] = sym;
1166	ignore[symind] = ignorethis;
1167	val = sym + (skipsym(sym) - sym);
1168	if (definethis) {
1169		if (*val == '=') {
1170			value[symind] = val+1;
1171			*val = '\0';
1172		} else if (*val == '\0')
1173			value[symind] = "1";
1174		else
1175			usage();
1176	} else {
1177		if (*val != '\0')
1178			usage();
1179		value[symind] = NULL;
1180	}
1181	debug("addsym %s=%s", symname[symind],
1182	    value[symind] ? value[symind] : "undef");
1183}
1184
1185/*
1186 * Compare s with n characters of t.
1187 * The same as strncmp() except that it checks that s[n] == '\0'.
1188 */
1189static int
1190strlcmp(const char *s, const char *t, size_t n)
1191{
1192	while (n-- && *t != '\0')
1193		if (*s != *t)
1194			return ((unsigned char)*s - (unsigned char)*t);
1195		else
1196			++s, ++t;
1197	return ((unsigned char)*s);
1198}
1199
1200/*
1201 * Diagnostics.
1202 */
1203static void
1204debug(const char *msg, ...)
1205{
1206	va_list ap;
1207
1208	if (debugging) {
1209		va_start(ap, msg);
1210		vwarnx(msg, ap);
1211		va_end(ap);
1212	}
1213}
1214
1215static void
1216error(const char *msg)
1217{
1218	if (depth == 0)
1219		warnx("%s: %d: %s", filename, linenum, msg);
1220	else
1221		warnx("%s: %d: %s (#if line %d depth %d)",
1222		    filename, linenum, msg, stifline[depth], depth);
1223	closeout();
1224	errx(2, "output may be truncated");
1225}