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