#include <sys/types.h>

#include <sys/stat.h>

#include <ctype.h>

#include <err.h>

#include <errno.h>

#include <stdarg.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

const char copyright[] =

"@(#) $Version: unifdef-2.5 $\n"

"@(#) $Author: Tony Finch (dot@dotat.at) $\n"

"@(#) $URL: http://dotat.at/prog/unifdef $\n"

;

typedef enum {

LT_TRUEI, /* a true #if with ignore flag */

LT_FALSEI, /* a false #if with ignore flag */

LT_IF, /* an unknown #if */

LT_TRUE, /* a true #if */

LT_FALSE, /* a false #if */

LT_ELIF, /* an unknown #elif */

LT_ELTRUE, /* a true #elif */

LT_ELFALSE, /* a false #elif */

LT_ELSE, /* #else */

LT_ENDIF, /* #endif */

LT_DODGY, /* flag: directive is not on one line */

LT_DODGY_LAST = LT_DODGY + LT_ENDIF,

LT_PLAIN, /* ordinary line */

LT_EOF, /* end of file */

LT_ERROR, /* unevaluable #if */

LT_COUNT

} Linetype;

static char const * const linetype_name[] = {

"TRUEI", "FALSEI", "IF", "TRUE", "FALSE",

"ELIF", "ELTRUE", "ELFALSE", "ELSE", "ENDIF",

"DODGY TRUEI", "DODGY FALSEI",

"DODGY IF", "DODGY TRUE", "DODGY FALSE",

"DODGY ELIF", "DODGY ELTRUE", "DODGY ELFALSE",

"DODGY ELSE", "DODGY ENDIF",

"PLAIN", "EOF", "ERROR"

};

typedef enum {

IS_OUTSIDE,

IS_FALSE_PREFIX, /* false #if followed by false #elifs */

IS_TRUE_PREFIX, /* first non-false #(el)if is true */

IS_PASS_MIDDLE, /* first non-false #(el)if is unknown */

IS_FALSE_MIDDLE, /* a false #elif after a pass state */

IS_TRUE_MIDDLE, /* a true #elif after a pass state */

IS_PASS_ELSE, /* an else after a pass state */

IS_FALSE_ELSE, /* an else after a true state */

IS_TRUE_ELSE, /* an else after only false states */

IS_FALSE_TRAILER, /* #elifs after a true are false */

IS_COUNT

} Ifstate;

static char const * const ifstate_name[] = {

"OUTSIDE", "FALSE_PREFIX", "TRUE_PREFIX",

"PASS_MIDDLE", "FALSE_MIDDLE", "TRUE_MIDDLE",

"PASS_ELSE", "FALSE_ELSE", "TRUE_ELSE",

"FALSE_TRAILER"

};

typedef enum {

NO_COMMENT = false, /* outside a comment */

C_COMMENT, /* in a comment like this one */

CXX_COMMENT, /* between // and end of line */

STARTING_COMMENT, /* just after slash-backslash-newline */

FINISHING_COMMENT, /* star-backslash-newline in a C comment */

CHAR_LITERAL, /* inside '' */

STRING_LITERAL /* inside "" */

} Comment_state;

static char const * const comment_name[] = {

"NO", "C", "CXX", "STARTING", "FINISHING", "CHAR", "STRING"

};

typedef enum {

LS_START, /* only space and comments on this line */

LS_HASH, /* only space, comments, and a hash */

LS_DIRTY /* this line can't be a preprocessor line */

} Line_state;

static char const * const linestate_name[] = {

"START", "HASH", "DIRTY"

};

#define MAXDEPTH 64 /* maximum #if nesting */

#define MAXLINE 4096 /* maximum length of line */

#define MAXSYMS 4096 /* maximum number of symbols */

#define EDITSLOP 10

#define TEMPLATE "unifdef.XXXXXX"

static bool compblank; /* -B: compress blank lines */

static bool lnblank; /* -b: blank deleted lines */

static bool complement; /* -c: do the complement */

static bool debugging; /* -d: debugging reports */

static bool iocccok; /* -e: fewer IOCCC errors */

static bool strictlogic; /* -K: keep ambiguous #ifs */

static bool killconsts; /* -k: eval constant #ifs */

static bool lnnum; /* -n: add #line directives */

static bool symlist; /* -s: output symbol list */

static bool symdepth; /* -S: output symbol depth */

static bool text; /* -t: this is a text file */

static const char *symname[MAXSYMS]; /* symbol name */

static const char *value[MAXSYMS]; /* -Dsym=value */

static bool ignore[MAXSYMS]; /* -iDsym or -iUsym */

static int nsyms; /* number of symbols */

static FILE *input; /* input file pointer */

static const char *filename; /* input file name */

static int linenum; /* current line number */

static FILE *output; /* output file pointer */

static const char *ofilename; /* output file name */

static bool overwriting; /* output overwrites input */

static char tempname[FILENAME_MAX]; /* used when overwriting */

static char tline[MAXLINE+EDITSLOP];/* input buffer plus space */

static char *keyword; /* used for editing #elif's */

static const char *newline; /* input file format */

static const char newline_unix[] = "\n";

static const char newline_crlf[] = "\r\n";

static Comment_state incomment; /* comment parser state */

static Line_state linestate; /* #if line parser state */

static Ifstate ifstate[MAXDEPTH]; /* #if processor state */

static bool ignoring[MAXDEPTH]; /* ignore comments state */

static int stifline[MAXDEPTH]; /* start of current #if */

static int depth; /* current #if nesting */

static int delcount; /* count of deleted lines */

static unsigned blankcount; /* count of blank lines */

static unsigned blankmax; /* maximum recent blankcount */

static bool constexpr; /* constant #if expression */

static bool zerosyms = true; /* to format symdepth output */

static bool firstsym; /* ditto */

static int exitstat; /* program exit status */

static void addsym(bool, bool, char *);

static void closeout(void);

static void debug(const char *, ...);

static void done(void);

static void error(const char *);

static int findsym(const char *);

static void flushline(bool);

static Linetype parseline(void);

static Linetype ifeval(const char **);

static void ignoreoff(void);

static void ignoreon(void);

static void keywordedit(const char *);

static void nest(void);

static void process(void);

static const char *skipargs(const char *);

static const char *skipcomment(const char *);

static const char *skipsym(const char *);

static void state(Ifstate);

static int strlcmp(const char *, const char *, size_t);

static void unnest(void);

static void usage(void);

static void version(void);

#define endsym(c) (!isalnum((unsigned char)c) && c != '_')

main(int argc, char *argv[])

{

int opt;

while ((opt = getopt(argc, argv, "i:D:U:I:o:bBcdeKklnsStV")) != -1)

switch (opt) {

case 'i': /* treat stuff controlled by these symbols as text */

/*

opt = *optarg++;

if (opt == 'D')

addsym(true, true, optarg);

else if (opt == 'U')

addsym(true, false, optarg);

else

usage();

break;

case 'D': /* define a symbol */

addsym(false, true, optarg);

break;

case 'U': /* undef a symbol */

addsym(false, false, optarg);

break;

case 'I': /* no-op for compatibility with cpp */

break;

case 'b': /* blank deleted lines instead of omitting them */

case 'l': /* backwards compatibility */

lnblank = true;

break;

case 'B': /* compress blank lines around removed section */

compblank = true;

break;

case 'c': /* treat -D as -U and vice versa */

complement = true;

break;

case 'd':

debugging = true;

break;

case 'e': /* fewer errors from dodgy lines */

iocccok = true;

break;

case 'K': /* keep ambiguous #ifs */

strictlogic = true;

break;

case 'k': /* process constant #ifs */

killconsts = true;

break;

case 'n': /* add #line directive after deleted lines */

lnnum = true;

break;

case 'o': /* output to a file */

ofilename = optarg;

break;

case 's': /* only output list of symbols that control #ifs */

symlist = true;

break;

case 'S': /* list symbols with their nesting depth */

symlist = symdepth = true;

break;

case 't': /* don't parse C comments */

text = true;

break;

case 'V': /* print version */

version();

default:

usage();

}

argc -= optind;

argv += optind;

if (compblank && lnblank)

errx(2, "-B and -b are mutually exclusive");

if (argc > 1) {

errx(2, "can only do one file");

} else if (argc == 1 && strcmp(*argv, "-") != 0) {

filename = *argv;

input = fopen(filename, "rb");

if (input == NULL)

err(2, "can't open %s", filename);

} else {

filename = "[stdin]";

input = stdin;

}

if (ofilename == NULL) {

ofilename = "[stdout]";

output = stdout;

} else {

struct stat ist, ost;

if (stat(ofilename, &ost) == 0 &&

fstat(fileno(input), &ist) == 0)

overwriting = (ist.st_dev == ost.st_dev

&& ist.st_ino == ost.st_ino);

if (overwriting) {

const char *dirsep;

int ofd;

dirsep = strrchr(ofilename, '/');

if (dirsep != NULL)

snprintf(tempname, sizeof(tempname),

"%.*s/" TEMPLATE,

(int)(dirsep - ofilename), ofilename);

else

snprintf(tempname, sizeof(tempname),

TEMPLATE);

ofd = mkstemp(tempname);

if (ofd != -1)

output = fdopen(ofd, "wb+");

if (output == NULL)

err(2, "can't create temporary file");

fchmod(ofd, ist.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO));

} else {

output = fopen(ofilename, "wb");

if (output == NULL)

err(2, "can't open %s", ofilename);

}

}

process();

abort(); /* bug */

}

static void

version(void)

{

const char *c = copyright;

for (;;) {

while (*++c != '$')

if (*c == '\0')

exit(0);

while (*++c != '$')

putc(*c, stderr);

putc('\n', stderr);

}

}

static void

usage(void)

{

fprintf(stderr, "usage: unifdef [-bBcdeKknsStV] [-Ipath]"

" [-Dsym[=val]] [-Usym] [-iDsym[=val]] [-iUsym] ... [file]\n");

exit(2);

}

typedef void state_fn(void);

static void Eelif (void) { error("Inappropriate #elif"); }

static void Eelse (void) { error("Inappropriate #else"); }

static void Eendif(void) { error("Inappropriate #endif"); }

static void Eeof (void) { error("Premature EOF"); }

static void Eioccc(void) { error("Obfuscated preprocessor control line"); }

static void print (void) { flushline(true); }

static void drop (void) { flushline(false); }

static void Strue (void) { drop(); ignoreoff(); state(IS_TRUE_PREFIX); }

static void Sfalse(void) { drop(); ignoreoff(); state(IS_FALSE_PREFIX); }

static void Selse (void) { drop(); state(IS_TRUE_ELSE); }

static void Pelif (void) { print(); ignoreoff(); state(IS_PASS_MIDDLE); }

static void Pelse (void) { print(); state(IS_PASS_ELSE); }

static void Pendif(void) { print(); unnest(); }

static void Dfalse(void) { drop(); ignoreoff(); state(IS_FALSE_TRAILER); }

static void Delif (void) { drop(); ignoreoff(); state(IS_FALSE_MIDDLE); }

static void Delse (void) { drop(); state(IS_FALSE_ELSE); }

static void Dendif(void) { drop(); unnest(); }

static void Fdrop (void) { nest(); Dfalse(); }

static void Fpass (void) { nest(); Pelif(); }

static void Ftrue (void) { nest(); Strue(); }

static void Ffalse(void) { nest(); Sfalse(); }

static void Oiffy (void) { if (!iocccok) Eioccc(); Fpass(); ignoreon(); }

static void Oif (void) { if (!iocccok) Eioccc(); Fpass(); }

static void Oelif (void) { if (!iocccok) Eioccc(); Pelif(); }

static void Idrop (void) { Fdrop(); ignoreon(); }

static void Itrue (void) { Ftrue(); ignoreon(); }

static void Ifalse(void) { Ffalse(); ignoreon(); }

static void Mpass (void) { strncpy(keyword, "if ", 4); Pelif(); }

static void Mtrue (void) { keywordedit("else"); state(IS_TRUE_MIDDLE); }

static void Melif (void) { keywordedit("endif"); state(IS_FALSE_TRAILER); }

static void Melse (void) { keywordedit("endif"); state(IS_FALSE_ELSE); }

static state_fn * const trans_table[IS_COUNT][LT_COUNT] = {

{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Eelif, Eelif, Eelif, Eelse, Eendif,

Oiffy, Oiffy, Fpass, Oif, Oif, Eelif, Eelif, Eelif, Eelse, Eendif,

print, done, abort },

{ Idrop, Idrop, Fdrop, Fdrop, Fdrop, Mpass, Strue, Sfalse,Selse, Dendif,

Idrop, Idrop, Fdrop, Fdrop, Fdrop, Mpass, Eioccc,Eioccc,Eioccc,Eioccc,

drop, Eeof, abort },

{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Dfalse,Dfalse,Dfalse,Delse, Dendif,

Oiffy, Oiffy, Fpass, Oif, Oif, Eioccc,Eioccc,Eioccc,Eioccc,Eioccc,

print, Eeof, abort },

{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Pelif, Mtrue, Delif, Pelse, Pendif,

Oiffy, Oiffy, Fpass, Oif, Oif, Pelif, Oelif, Oelif, Pelse, Pendif,

print, Eeof, abort },

{ Idrop, Idrop, Fdrop, Fdrop, Fdrop, Pelif, Mtrue, Delif, Pelse, Pendif,

Idrop, Idrop, Fdrop, Fdrop, Fdrop, Eioccc,Eioccc,Eioccc,Eioccc,Eioccc,

drop, Eeof, abort },

{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Melif, Melif, Melif, Melse, Pendif,

Oiffy, Oiffy, Fpass, Oif, Oif, Eioccc,Eioccc,Eioccc,Eioccc,Pendif,

print, Eeof, abort },

{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Eelif, Eelif, Eelif, Eelse, Pendif,

Oiffy, Oiffy, Fpass, Oif, Oif, Eelif, Eelif, Eelif, Eelse, Pendif,

print, Eeof, abort },

{ Idrop, Idrop, Fdrop, Fdrop, Fdrop, Eelif, Eelif, Eelif, Eelse, Dendif,

Idrop, Idrop, Fdrop, Fdrop, Fdrop, Eelif, Eelif, Eelif, Eelse, Eioccc,

drop, Eeof, abort },

{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Eelif, Eelif, Eelif, Eelse, Dendif,

Oiffy, Oiffy, Fpass, Oif, Oif, Eelif, Eelif, Eelif, Eelse, Eioccc,

print, Eeof, abort },

{ Idrop, Idrop, Fdrop, Fdrop, Fdrop, Dfalse,Dfalse,Dfalse,Delse, Dendif,

Idrop, Idrop, Fdrop, Fdrop, Fdrop, Dfalse,Dfalse,Dfalse,Delse, Eioccc,

drop, Eeof, abort }

};

static void

ignoreoff(void)

{

if (depth == 0)

abort(); /* bug */

ignoring[depth] = ignoring[depth-1];

}

static void

ignoreon(void)

{

ignoring[depth] = true;

}

static void

keywordedit(const char *replacement)

{

snprintf(keyword, tline + sizeof(tline) - keyword,

"%s%s", replacement, newline);

print();

}

static void

nest(void)

{

if (depth > MAXDEPTH-1)

abort(); /* bug */

if (depth == MAXDEPTH-1)

error("Too many levels of nesting");

depth += 1;

stifline[depth] = linenum;

}

static void

unnest(void)

{

if (depth == 0)

abort(); /* bug */

depth -= 1;

}

static void

state(Ifstate is)

{

ifstate[depth] = is;

}

static void

flushline(bool keep)

{

if (symlist)

return;

if (keep ^ complement) {

bool blankline = tline[strspn(tline, " \t\r\n")] == '\0';

if (blankline && compblank && blankcount != blankmax) {

delcount += 1;

blankcount += 1;

} else {

if (lnnum && delcount > 0)

printf("#line %d%s", linenum, newline);

fputs(tline, output);

delcount = 0;

blankmax = blankcount = blankline ? blankcount + 1 : 0;

}

} else {

if (lnblank)

fputs(newline, output);

exitstat = 1;

delcount += 1;

blankcount = 0;

}

if (debugging)

fflush(output);

}

static void

process(void)

{

/* When compressing blank lines, act as if the file

blankmax = blankcount = 1000;

for (;;) {

Linetype lineval = parseline();

trans_table[ifstate[depth]][lineval]();

debug("process line %d %s -> %s depth %d",

linenum, linetype_name[lineval],

ifstate_name[ifstate[depth]], depth);

}

}

static void

closeout(void)

{

if (symdepth && !zerosyms)

printf("\n");

if (fclose(output) == EOF) {

warn("couldn't write to %s", ofilename);

if (overwriting) {

unlink(tempname);

errx(2, "%s unchanged", filename);

} else {

exit(2);

}

}

}

static void

done(void)

{

if (incomment)

error("EOF in comment");

closeout();

if (overwriting && rename(tempname, ofilename) == -1) {

warn("couldn't rename temporary file");

unlink(tempname);

errx(2, "%s unchanged", ofilename);

}

exit(exitstat);

}

static Linetype

parseline(void)

{

const char *cp;

int cursym;

int kwlen;

Linetype retval;

Comment_state wascomment;

linenum++;

if (fgets(tline, MAXLINE, input) == NULL)

return (LT_EOF);

if (newline == NULL) {

if (strrchr(tline, '\n') == strrchr(tline, '\r') + 1)

newline = newline_crlf;

else

newline = newline_unix;

}

retval = LT_PLAIN;

wascomment = incomment;

cp = skipcomment(tline);

if (linestate == LS_START) {

if (*cp == '#') {

linestate = LS_HASH;

firstsym = true;

cp = skipcomment(cp + 1);

} else if (*cp != '\0')

linestate = LS_DIRTY;

}

if (!incomment && linestate == LS_HASH) {

keyword = tline + (cp - tline);

cp = skipsym(cp);

kwlen = cp - keyword;

/* no way can we deal with a continuation inside a keyword */

if (strncmp(cp, "\\\r\n", 3) == 0 ||

strncmp(cp, "\\\n", 2) == 0)

Eioccc();

if (strlcmp("ifdef", keyword, kwlen) == 0 ||

strlcmp("ifndef", keyword, kwlen) == 0) {

cp = skipcomment(cp);

if ((cursym = findsym(cp)) < 0)

retval = LT_IF;

else {

retval = (keyword[2] == 'n')

? LT_FALSE : LT_TRUE;

if (value[cursym] == NULL)

retval = (retval == LT_TRUE)

? LT_FALSE : LT_TRUE;

if (ignore[cursym])

retval = (retval == LT_TRUE)

? LT_TRUEI : LT_FALSEI;

}

cp = skipsym(cp);

} else if (strlcmp("if", keyword, kwlen) == 0)

retval = ifeval(&cp);

else if (strlcmp("elif", keyword, kwlen) == 0)

retval = ifeval(&cp) - LT_IF + LT_ELIF;

else if (strlcmp("else", keyword, kwlen) == 0)

retval = LT_ELSE;

else if (strlcmp("endif", keyword, kwlen) == 0)

retval = LT_ENDIF;

else {

linestate = LS_DIRTY;

retval = LT_PLAIN;

}

cp = skipcomment(cp);

if (*cp != '\0') {

linestate = LS_DIRTY;

if (retval == LT_TRUE || retval == LT_FALSE ||

retval == LT_TRUEI || retval == LT_FALSEI)

retval = LT_IF;

if (retval == LT_ELTRUE || retval == LT_ELFALSE)

retval = LT_ELIF;

}

if (retval != LT_PLAIN && (wascomment || incomment)) {

retval += LT_DODGY;

if (incomment)

linestate = LS_DIRTY;

}

/* skipcomment normally changes the state, except

if (linestate == LS_HASH) {

size_t len = cp - tline;

if (fgets(tline + len, MAXLINE - len, input) == NULL) {

/* append the missing newline */

strcpy(tline + len, newline);

cp += strlen(newline);

linestate = LS_START;

} else {

linestate = LS_DIRTY;

}

}

}

if (linestate == LS_DIRTY) {

while (*cp != '\0')

cp = skipcomment(cp + 1);

}

debug("parser line %d state %s comment %s line", linenum,

comment_name[incomment], linestate_name[linestate]);

return (retval);

}

static Linetype op_strict(int *p, int v, Linetype at, Linetype bt) {

if(at == LT_IF || bt == LT_IF) return (LT_IF);

return (*p = v, v ? LT_TRUE : LT_FALSE);

}

static Linetype op_lt(int *p, Linetype at, int a, Linetype bt, int b) {

return op_strict(p, a < b, at, bt);

}

static Linetype op_gt(int *p, Linetype at, int a, Linetype bt, int b) {

return op_strict(p, a > b, at, bt);

}

static Linetype op_le(int *p, Linetype at, int a, Linetype bt, int b) {

return op_strict(p, a <= b, at, bt);

}

static Linetype op_ge(int *p, Linetype at, int a, Linetype bt, int b) {

return op_strict(p, a >= b, at, bt);

}

static Linetype op_eq(int *p, Linetype at, int a, Linetype bt, int b) {

return op_strict(p, a == b, at, bt);

}

static Linetype op_ne(int *p, Linetype at, int a, Linetype bt, int b) {

return op_strict(p, a != b, at, bt);

}

static Linetype op_or(int *p, Linetype at, int a, Linetype bt, int b) {

if (!strictlogic && (at == LT_TRUE || bt == LT_TRUE))

return (*p = 1, LT_TRUE);

return op_strict(p, a || b, at, bt);

}

static Linetype op_and(int *p, Linetype at, int a, Linetype bt, int b) {

if (!strictlogic && (at == LT_FALSE || bt == LT_FALSE))

return (*p = 0, LT_FALSE);

return op_strict(p, a && b, at, bt);

}

struct ops;

typedef Linetype eval_fn(const struct ops *, int *, const char **);

static eval_fn eval_table, eval_unary;

static const struct ops {

eval_fn *inner;

struct op {

const char *str;

Linetype (*fn)(int *, Linetype, int, Linetype, int);

} op[5];

} eval_ops[] = {

{ eval_table, { { "||", op_or } } },

{ eval_table, { { "&&", op_and } } },

{ eval_table, { { "==", op_eq },

{ "!=", op_ne } } },

{ eval_unary, { { "<=", op_le },

{ ">=", op_ge },

{ "<", op_lt },

{ ">", op_gt } } }

};

static Linetype

eval_unary(const struct ops *ops, int *valp, const char **cpp)

{

const char *cp;

char *ep;

int sym;

bool defparen;

Linetype lt;

cp = skipcomment(*cpp);

if (*cp == '!') {

debug("eval%d !", ops - eval_ops);

cp++;

lt = eval_unary(ops, valp, &cp);

if (lt == LT_ERROR)

return (LT_ERROR);

if (lt != LT_IF) {

*valp = !*valp;

lt = *valp ? LT_TRUE : LT_FALSE;

}

} else if (*cp == '(') {

cp++;

debug("eval%d (", ops - eval_ops);

lt = eval_table(eval_ops, valp, &cp);

if (lt == LT_ERROR)

return (LT_ERROR);

cp = skipcomment(cp);

if (*cp++ != ')')

return (LT_ERROR);

} else if (isdigit((unsigned char)*cp)) {

debug("eval%d number", ops - eval_ops);

*valp = strtol(cp, &ep, 0);

if (ep == cp)

return (LT_ERROR);

lt = *valp ? LT_TRUE : LT_FALSE;

cp = skipsym(cp);

} else if (strncmp(cp, "defined", 7) == 0 && endsym(cp[7])) {

cp = skipcomment(cp+7);

debug("eval%d defined", ops - eval_ops);

if (*cp == '(') {

cp = skipcomment(cp+1);

defparen = true;

} else {

defparen = false;

}

sym = findsym(cp);

if (sym < 0) {

lt = LT_IF;

} else {

*valp = (value[sym] != NULL);

lt = *valp ? LT_TRUE : LT_FALSE;

}

cp = skipsym(cp);

cp = skipcomment(cp);

if (defparen && *cp++ != ')')

return (LT_ERROR);

constexpr = false;

} else if (!endsym(*cp)) {

debug("eval%d symbol", ops - eval_ops);

sym = findsym(cp);

cp = skipsym(cp);

if (sym < 0) {

lt = LT_IF;

cp = skipargs(cp);

} else if (value[sym] == NULL) {

*valp = 0;

lt = LT_FALSE;

} else {

*valp = strtol(value[sym], &ep, 0);

if (*ep != '\0' || ep == value[sym])

return (LT_ERROR);

lt = *valp ? LT_TRUE : LT_FALSE;

cp = skipargs(cp);

}

constexpr = false;

} else {

debug("eval%d bad expr", ops - eval_ops);

return (LT_ERROR);

}

*cpp = cp;

debug("eval%d = %d", ops - eval_ops, *valp);

return (lt);

}

static Linetype

eval_table(const struct ops *ops, int *valp, const char **cpp)

{

const struct op *op;

const char *cp;

int val;

Linetype lt, rt;

debug("eval%d", ops - eval_ops);

cp = *cpp;

lt = ops->inner(ops+1, valp, &cp);

if (lt == LT_ERROR)

return (LT_ERROR);

for (;;) {

cp = skipcomment(cp);

for (op = ops->op; op->str != NULL; op++)

if (strncmp(cp, op->str, strlen(op->str)) == 0)

break;

if (op->str == NULL)

break;

cp += strlen(op->str);

debug("eval%d %s", ops - eval_ops, op->str);

rt = ops->inner(ops+1, &val, &cp);

if (rt == LT_ERROR)

return (LT_ERROR);

lt = op->fn(valp, lt, *valp, rt, val);

}

*cpp = cp;

debug("eval%d = %d", ops - eval_ops, *valp);

debug("eval%d lt = %s", ops - eval_ops, linetype_name[lt]);

return (lt);

}

static Linetype

ifeval(const char **cpp)

{

int ret;

int val = 0;

debug("eval %s", *cpp);

constexpr = killconsts ? false : true;

ret = eval_table(eval_ops, &val, cpp);

debug("eval = %d", val);

return (constexpr ? LT_IF : ret == LT_ERROR ? LT_IF : ret);

}

static const char *

skipcomment(const char *cp)

{

if (text || ignoring[depth]) {

for (; isspace((unsigned char)*cp); cp++)

if (*cp == '\n')

linestate = LS_START;

return (cp);

}

while (*cp != '\0')

/* don't reset to LS_START after a line continuation */

if (strncmp(cp, "\\\r\n", 3) == 0)

cp += 3;

else if (strncmp(cp, "\\\n", 2) == 0)

cp += 2;

else switch (incomment) {

case NO_COMMENT:

if (strncmp(cp, "/\\\r\n", 4) == 0) {

incomment = STARTING_COMMENT;

cp += 4;

} else if (strncmp(cp, "/\\\n", 3) == 0) {

incomment = STARTING_COMMENT;

cp += 3;

} else if (strncmp(cp, "/*", 2) == 0) {

incomment = C_COMMENT;

cp += 2;

} else if (strncmp(cp, "//", 2) == 0) {

incomment = CXX_COMMENT;

cp += 2;

} else if (strncmp(cp, "\'", 1) == 0) {