New USE() macros

For each CONFIG_SYMBOL, include/bb_config.h now has both ENABLE_SYMBOL
and USE_SYMBOL(x).  ENABLE_SYMBOL is still always defined (1 or 0) so that
if(ENABLE) should optimize out when it's zero.  The USE_SYMBOL(X) will only
splice in X if the symbol is defined, otherwise it'll be empty.

Thus we can convert this:

#ifdef CONFIG_ARGS
    opt = bb_getopt_ulflags(argc, argv, "ab:c"
#ifdef CONFIG_THINGY
        "d:"
#endif
        , &bvalue
#ifdef CONFIG_THINGY
        , &thingy
#endif
    );
#endif

into this:
    if (ENABLE_ARGS) {
        opt = bb_getopt_ulflags(argc, argv, "ab:c" USE_THINGY("d:"), &bvalue
                USE_THINGY(, &thingy));
    }

And it should produce the same code.

Unlike the old versions in include/_usage.h, the new USE_SYMBOL(x) can handle
commas in its arguments (as shown above).  (The _usage.h file is obsolete and
no longer generated.)

Nobody should need to include config.h directly anymore, bb_config.h should
define all the configuration stuff we need.  Someday, the CONFIG_SYMBOL
versions should go away in favor of ENABLE_SYMBOL and USE_SYMBOL().

Thanks to vodz for the new version of bb_mkdep.c that works with function
macros.

1 files changed, 866 insertions, 65 deletions

diff --git a/scripts/bb_mkdep.c b/scripts/bb_mkdep.c
index 3fea20aed..7219feef9 100644
--- a/scripts/bb_mkdep.c
+++ b/scripts/bb_mkdep.c
@@ -1,10 +1,15 @@
 /*
- * Another fast dependencies generator for Makefiles, Version 3.0
+ * Another fast dependencies generator for Makefiles, Version 4.0
  *
- * Copyright (C) 2005 by Vladimir Oleynik <dzo@simtreas.ru>
+ * Copyright (C) 2005,2006 by Vladimir Oleynik <dzo@simtreas.ru>
  *
  * mmaping file may be originally by Linus Torvalds.
  *
+ * infix parser/evaluator for #if expression
+ *      Copyright (c) 2001 Aaron Lehmann <aaronl@vitelus.com>
+ *      Copyright (c) 2001 Manuel Novoa III <mjn3@codepoet.org>
+ *      Copyright (c) 2003 Vladimir Oleynik <dzo@simtreas.ru>
+ *
  * bb_simplify_path()
  *      Copyright (C) 2005 Manuel Novoa III <mjn3@codepoet.org>
  *
@@ -15,7 +20,7 @@
  *      Copyright (C) 2003 Glenn McGrath
  *      Copyright (C) Vladimir Oleynik <dzo@simtreas.ru>
  *
- * (c) 2005 Bernhard Fischer:
+ * (c) 2005,2006 Bernhard Fischer:
  *  - commentary typos,
  *  - move "memory exhausted" into msg_enomem,
  *  - more verbose --help output.
@@ -29,6 +34,7 @@
  *    path/inc.h: include/config/key*.h found_included_include_*.h
  * 5) save include/config/key*.h if changed after previous usage
  * This program does not generate dependencies for #include <...>
+ * Config file can have #if #elif #else #ifdef #ifndef #endif lines
  */
 
 #define LOCAL_INCLUDE_PATH          "include"
@@ -103,9 +109,9 @@ static llist_t *configs;    /* list of -c usaged and them stat() after parsed */
 static llist_t *Iop;        /* list of -I include usaged */
 
 static char *pwd;           /* current work directory */
-static size_t replace;      /* replace current work directory with build dir */
+static size_t replace;      /* replace current work derectory to build dir */
 
-static const char *kp;      /* KEY path, argument of -k used */
+static const char *kp;      /* KEY path, argument of -k usaged */
 static size_t kp_len;
 static struct stat st_kp;   /* stat(kp) */
 
@@ -139,22 +145,44 @@ static inline bb_key_t *check_key(bb_key_t *k, const char *nk, size_t key_sz)
     return NULL;
 }
 
+static inline const char *lookup_key(const char *nk, size_t key_sz)
+{
+    bb_key_t *cur;
+
+    for(cur = key_top; cur; cur = cur->next) {
+	if(key_sz == cur->key_sz && memcmp(cur->keyname, nk, key_sz) == 0) {
+	    return cur->value;
+	}
+    }
+    return NULL;
+}
+
 /* for lexical analyser */
 static int pagesizem1;      /* padding mask = getpagesize() - 1 */
 
 /* for speed tricks */
 static char first_chars[1+UCHAR_MAX];               /* + L_EOF */
 static char isalnums[1+UCHAR_MAX];                  /* + L_EOF */
-/* trick for fast find "define", "include", "undef" */
-static const char first_chars_diu[UCHAR_MAX] = {
-	[(int)'d'] = (char)5,           /* strlen("define")  - 1; */
-	[(int)'i'] = (char)6,           /* strlen("include") - 1; */
-	[(int)'u'] = (char)4,           /* strlen("undef")   - 1; */
+
+/* trick for fast find "define", "include", "undef",
+"if((n)def)" "else", "endif"  */
+static const char * const preproc[] = {
+/* 0   1       2      3       4     5       6        7         8      9 */
+"", "efine", "lif", "lse", "ndif", "f", "fdef", "fndef", "nclude", "ndef" };
+static const unsigned char first_chars_deiu[UCHAR_MAX] = {
+	[(int)'d'] = (unsigned char)(1|0x10),     /* define */
+	[(int)'e'] = (unsigned char)(2|0x40),     /* elif, else, endif  */
+	[(int)'i'] = (unsigned char)(5|0x80),     /* if ifdef ifndef include */
+	[(int)'u'] = (unsigned char)(9|0x90),     /* undef */
 };
 
 #define CONFIG_MODE  0
-#define SOURCES_MODE 1
-static int mode;
+#define IF0_MODE     1  /* #if 0  */
+#define IF1_MODE     2  /* #if 1 */
+#define ELSE0_MODE   4  /* #else found after #if 0 */
+#define ELSE1_MODE   8  /* #else found after #if 1 */
+#define ELIF1_MODE   16 /* #elif found after #if 1 */
+#define FALSE_MODES  (IF0_MODE|ELSE1_MODE|ELIF1_MODE)
 
 #define yy_error_d(s) bb_error_d("%s:%d hmm, %s", fname, line, s)
 
@@ -165,9 +193,15 @@ static int mode;
 #define REM    '/'      /* block comment */
 #define BS     '\\'     /* back slash */
 #define POUND  '#'      /* # */
-#define D      '5'      /* #define preprocessor's directive */
-#define I      '6'      /* #include preprocessor's directive */
-#define U      '4'      /* #undef preprocessor's directive */
+#define D      '1'      /* #define preprocessor's directive */
+#define EI     '2'      /* #elif preprocessor's directive */
+#define E      '3'      /* #else preprocessor's directive */
+#define EF     '4'      /* #endif preprocessor's directive */
+#define F      '5'      /* #if preprocessor's directive */
+#define IFD    '6'      /* #ifdef preprocessor's directive */
+#define IFND   '7'      /* #ifndef preprocessor's directive */
+#define I      '8'      /* #include preprocessor's directive */
+#define U      '9'      /* #undef preprocessor's directive */
 #define DK     'K'      /* #define KEY... (config mode) */
 #define ANY    '*'      /* any unparsed chars */
 
@@ -189,16 +223,508 @@ static char id_s[4096];
 #define put_id(ic)  do {    if(id_len == sizeof(id_s)) goto too_long; \
 				id[id_len++] = ic; } while(0)
 
+static char ifcpp_stack[1024];
+static int  ptr_ifcpp_stack;
+#define push_mode() do { \
+			if(ptr_ifcpp_stack == (int)sizeof(ifcpp_stack)) \
+				yy_error_d("#if* stack overflow"); \
+			ifcpp_stack[ptr_ifcpp_stack++] = (char)mode; \
+			} while(0)
+
+#define pop_mode()  do { \
+			if(ptr_ifcpp_stack == 0) \
+				yy_error_d("unexpected #endif"); \
+			mode = ifcpp_stack[--ptr_ifcpp_stack]; \
+			} while(0)
+
+/* #if expression */
+typedef long long arith_t;
+
+static arith_t arith (const char *expr, int *perrcode);
+
+/* The code uses a simple two-stack algorithm. See
+ * http://www.onthenet.com.au/~grahamis/int2008/week02/lect02.html
+ * for a detailed explanation of the infix-to-postfix algorithm on which
+ * this is based (this code differs in that it applies operators immediately
+ * to the stack instead of adding them to a queue to end up with an
+ * expression). */
+
+#define arith_isspace(arithval) \
+	(arithval == ' ' || arithval == '\v' || arithval == '\t' || arithval == '\f')
+
+
+typedef unsigned char operator;
+
+/* An operator's token id is a bit of a bitfield. The lower 5 bits are the
+ * precedence, and 3 high bits are an ID unique across operators of that
+ * precedence. The ID portion is so that multiple operators can have the
+ * same precedence, ensuring that the leftmost one is evaluated first.
+ * Consider * and /. */
+
+#define tok_decl(prec,id) (((id)<<5)|(prec))
+#define PREC(op) ((op) & 0x1F)
+
+#define TOK_LPAREN tok_decl(0,0)
+
+#define TOK_COMMA tok_decl(1,0)
+
+/* conditional is right associativity too */
+#define TOK_CONDITIONAL tok_decl(2,0)
+#define TOK_CONDITIONAL_SEP tok_decl(2,1)
+
+#define TOK_OR tok_decl(3,0)
+
+#define TOK_AND tok_decl(4,0)
+
+#define TOK_BOR tok_decl(5,0)
+
+#define TOK_BXOR tok_decl(6,0)
+
+#define TOK_BAND tok_decl(7,0)
+
+#define TOK_EQ tok_decl(8,0)
+#define TOK_NE tok_decl(8,1)
+
+#define TOK_LT tok_decl(9,0)
+#define TOK_GT tok_decl(9,1)
+#define TOK_GE tok_decl(9,2)
+#define TOK_LE tok_decl(9,3)
+
+#define TOK_LSHIFT tok_decl(10,0)
+#define TOK_RSHIFT tok_decl(10,1)
+
+#define TOK_ADD tok_decl(11,0)
+#define TOK_SUB tok_decl(11,1)
+
+#define TOK_MUL tok_decl(12,0)
+#define TOK_DIV tok_decl(12,1)
+#define TOK_REM tok_decl(12,2)
+
+/* For now unary operators. */
+#define UNARYPREC 13
+#define TOK_BNOT tok_decl(UNARYPREC,0)
+#define TOK_NOT tok_decl(UNARYPREC,1)
+
+#define TOK_UMINUS tok_decl(UNARYPREC+1,0)
+#define TOK_UPLUS tok_decl(UNARYPREC+1,1)
+
+#define SPEC_PREC (UNARYPREC+1)
+
+#define TOK_NUM tok_decl(SPEC_PREC, 0)
+#define TOK_RPAREN tok_decl(SPEC_PREC, 1)
 
-/* stupid C lexical analyser */
-static void c_lex(const char *fname, long fsize)
+#define NUMPTR (*numstackptr)
+
+typedef struct ARITCH_VAR_NUM {
+	arith_t val;
+	arith_t contidional_second_val;
+	char contidional_second_val_initialized;
+} v_n_t;
+
+
+typedef struct CHK_VAR_RECURSIVE_LOOPED {
+	const char *var;
+	size_t var_sz;
+	struct CHK_VAR_RECURSIVE_LOOPED *next;
+} chk_var_recursive_looped_t;
+
+static chk_var_recursive_looped_t *prev_chk_var_recursive;
+
+
+static int arith_lookup_val(const char *var, size_t key_sz, arith_t *pval)
+{
+    const char * p = lookup_key(var, key_sz);
+
+    if(p) {
+	int errcode;
+
+	/* recursive try as expression */
+	chk_var_recursive_looped_t *cur;
+	chk_var_recursive_looped_t cur_save;
+
+	for(cur = prev_chk_var_recursive; cur; cur = cur->next) {
+	    if(cur->var_sz == key_sz && memcmp(cur->var, var, key_sz) == 0) {
+		/* expression recursion loop detected */
+		return -5;
+	    }
+	}
+	/* save current lookuped var name */
+	cur = prev_chk_var_recursive;
+	cur_save.var = var;
+	cur_save.var_sz = key_sz;
+	cur_save.next = cur;
+	prev_chk_var_recursive = &cur_save;
+
+	*pval = arith (p, &errcode);
+	/* restore previous ptr after recursiving */
+	prev_chk_var_recursive = cur;
+	return errcode;
+    } else {
+	/* disallow undefined var */
+	fprintf(stderr, "%.*s ", (int)key_sz, var);
+	return -4;
+    }
+}
+
+/* "applying" a token means performing it on the top elements on the integer
+ * stack. For a unary operator it will only change the top element, but a
+ * binary operator will pop two arguments and push a result */
+static inline int
+arith_apply(operator op, v_n_t *numstack, v_n_t **numstackptr)
+{
+	v_n_t *numptr_m1;
+	arith_t numptr_val, rez;
+
+	if (NUMPTR == numstack) goto err; /* There is no operator that can work
+										 without arguments */
+	numptr_m1 = NUMPTR - 1;
+
+	rez = numptr_m1->val;
+	if (op == TOK_UMINUS)
+		rez *= -1;
+	else if (op == TOK_NOT)
+		rez = !rez;
+	else if (op == TOK_BNOT)
+		rez = ~rez;
+	else if (op != TOK_UPLUS) {
+		/* Binary operators */
+
+	    /* check and binary operators need two arguments */
+	    if (numptr_m1 == numstack) goto err;
+
+	    /* ... and they pop one */
+	    --NUMPTR;
+	    numptr_val = rez;
+	    if (op == TOK_CONDITIONAL) {
+		if(! numptr_m1->contidional_second_val_initialized) {
+		    /* protect $((expr1 ? expr2)) without ": expr" */
+		    goto err;
+		}
+		rez = numptr_m1->contidional_second_val;
+	    } else if(numptr_m1->contidional_second_val_initialized) {
+		    /* protect $((expr1 : expr2)) without "expr ? " */
+		    goto err;
+	    }
+	    numptr_m1 = NUMPTR - 1;
+	    if (op == TOK_CONDITIONAL) {
+		    numptr_m1->contidional_second_val = rez;
+	    }
+	    rez = numptr_m1->val;
+	    if (op == TOK_BOR)
+			rez |= numptr_val;
+	    else if (op == TOK_OR)
+			rez = numptr_val || rez;
+	    else if (op == TOK_BAND)
+			rez &= numptr_val;
+	    else if (op == TOK_BXOR)
+			rez ^= numptr_val;
+	    else if (op == TOK_AND)
+			rez = rez && numptr_val;
+	    else if (op == TOK_EQ)
+			rez = (rez == numptr_val);
+	    else if (op == TOK_NE)
+			rez = (rez != numptr_val);
+	    else if (op == TOK_GE)
+			rez = (rez >= numptr_val);
+	    else if (op == TOK_RSHIFT)
+			rez >>= numptr_val;
+	    else if (op == TOK_LSHIFT)
+			rez <<= numptr_val;
+	    else if (op == TOK_GT)
+			rez = (rez > numptr_val);
+	    else if (op == TOK_LT)
+			rez = (rez < numptr_val);
+	    else if (op == TOK_LE)
+			rez = (rez <= numptr_val);
+	    else if (op == TOK_MUL)
+			rez *= numptr_val;
+	    else if (op == TOK_ADD)
+			rez += numptr_val;
+	    else if (op == TOK_SUB)
+			rez -= numptr_val;
+	    else if (op == TOK_COMMA)
+			rez = numptr_val;
+	    else if (op == TOK_CONDITIONAL_SEP) {
+			if (numptr_m1 == numstack) {
+			    /* protect $((expr : expr)) without "expr ? " */
+			    goto err;
+			}
+			numptr_m1->contidional_second_val_initialized = op;
+			numptr_m1->contidional_second_val = numptr_val;
+	    }
+	    else if (op == TOK_CONDITIONAL) {
+			rez = rez ?
+			      numptr_val : numptr_m1->contidional_second_val;
+	    }
+	    else if(numptr_val==0)          /* zero divisor check */
+			return -2;
+	    else if (op == TOK_DIV)
+			rez /= numptr_val;
+	    else if (op == TOK_REM)
+			rez %= numptr_val;
+	}
+	numptr_m1->val = rez;
+	return 0;
+err: return(-1);
+}
+
+/* longest must first */
+static const char op_tokens[] = {
+	'<','<',    0, TOK_LSHIFT,
+	'>','>',    0, TOK_RSHIFT,
+	'|','|',    0, TOK_OR,
+	'&','&',    0, TOK_AND,
+	'!','=',    0, TOK_NE,
+	'<','=',    0, TOK_LE,
+	'>','=',    0, TOK_GE,
+	'=','=',    0, TOK_EQ,
+	'!',        0, TOK_NOT,
+	'<',        0, TOK_LT,
+	'>',        0, TOK_GT,
+	'|',        0, TOK_BOR,
+	'&',        0, TOK_BAND,
+	'*',        0, TOK_MUL,
+	'/',        0, TOK_DIV,
+	'%',        0, TOK_REM,
+	'+',        0, TOK_ADD,
+	'-',        0, TOK_SUB,
+	'^',        0, TOK_BXOR,
+	'~',        0, TOK_BNOT,
+	',',        0, TOK_COMMA,
+	'?',        0, TOK_CONDITIONAL,
+	':',        0, TOK_CONDITIONAL_SEP,
+	')',        0, TOK_RPAREN,
+	'(',        0, TOK_LPAREN,
+	0
+};
+/* ptr to ")" */
+#define endexpression &op_tokens[sizeof(op_tokens)-7]
+
+/*
+ * Return of a legal variable name (a letter or underscore followed by zero or
+ * more letters, underscores, and digits).
+ */
+
+static inline char *
+endofname(const char *name)
+{
+	char *p;
+
+	p = (char *) name;
+	if (! ID(*p))
+		return p;
+	while (*++p) {
+		if (! ISALNUM(*p))
+			break;
+	}
+	return p;
+}
+
+
+/* Like strncpy but make sure the resulting string is always 0 terminated. */
+static inline char * safe_strncpy(char *dst, const char *src, size_t size)
+{
+	dst[size-1] = '\0';
+	return strncpy(dst, src, size-1);
+}
+
+static arith_t arith (const char *expr, int *perrcode)
+{
+    char arithval;          /* Current character under analysis */
+    operator lasttok, op;
+    operator prec;
+
+    const char *p = endexpression;
+    int errcode;
+
+    size_t datasizes = strlen(expr) + 2;
+
+    /* Stack of integers */
+    /* The proof that there can be no more than strlen(startbuf)/2+1 integers
+     * in any given correct or incorrect expression is left as an exercise to
+     * the reader. */
+    v_n_t *numstack = alloca(((datasizes)/2)*sizeof(v_n_t)),
+	    *numstackptr = numstack;
+    /* Stack of operator tokens */
+    operator *stack = alloca((datasizes) * sizeof(operator)),
+	    *stackptr = stack;
+
+    *stackptr++ = lasttok = TOK_LPAREN;     /* start off with a left paren */
+    *perrcode = errcode = 0;
+
+    while(1) {
+	if ((arithval = *expr) == 0) {
+		if (p == endexpression) {
+			/* Null expression. */
+err:
+			return (*perrcode = -1);
+		}
+
+		/* This is only reached after all tokens have been extracted from the
+		 * input stream. If there are still tokens on the operator stack, they
+		 * are to be applied in order. At the end, there should be a final
+		 * result on the integer stack */
+
+		if (expr != endexpression + 1) {
+			/* If we haven't done so already, */
+			/* append a closing right paren */
+			expr = endexpression;
+			/* and let the loop process it. */
+			continue;
+		}
+		/* At this point, we're done with the expression. */
+		if (numstackptr != numstack+1) {
+			/* ... but if there isn't, it's bad */
+			goto err;
+		}
+	ret:
+		*perrcode = errcode;
+		return numstack->val;
+	} else {
+		/* Continue processing the expression. */
+		if (arith_isspace(arithval)) {
+			/* Skip whitespace */
+			goto prologue;
+		}
+		if((p = endofname(expr)) != expr) {
+			size_t var_name_size = (p-expr);
+
+			if(var_name_size == 7 &&
+				strncmp(expr, "defined", var_name_size) == 0) {
+			    int brace_form = 0;
+			    const char *v;
+
+			    while(arith_isspace(*p)) p++;
+			    if(*p == '(') {
+				p++;
+				while(arith_isspace(*p)) p++;
+				brace_form = 1;
+			    }
+			    expr = p;
+			    if((p = endofname(expr)) == expr)
+				goto err;
+			    var_name_size = (p-expr);
+			    while(arith_isspace(*p)) p++;
+			    if(brace_form && *p++ != ')')
+				goto err;
+			    v = lookup_key(expr, var_name_size);
+			    numstackptr->val = (v != NULL) ? 1 : 0;
+			} else {
+			    errcode = arith_lookup_val(expr, var_name_size,
+					&(numstackptr->val));
+			    if(errcode) goto ret;
+			}
+			expr = p;
+		num:
+			numstackptr->contidional_second_val_initialized = 0;
+			numstackptr++;
+			lasttok = TOK_NUM;
+			continue;
+		} else if (arithval >= '0' && arithval <= '9') {
+			numstackptr->val = strtoll(expr, (char **) &expr, 0);
+			while(*expr == 'l' || *expr == 'L' || *expr == 'u' ||
+								*expr == 'U')
+			    expr++;
+			goto num;
+		}
+		for(p = op_tokens; ; p++) {
+			const char *o;
+
+			if(*p == 0) {
+				/* strange operator not found */
+				goto err;
+			}
+			for(o = expr; *p && *o == *p; p++)
+				o++;
+			if(! *p) {
+				/* found */
+				expr = o - 1;
+				break;
+			}
+			/* skip tail uncompared token */
+			while(*p)
+				p++;
+			/* skip zero delim */
+			p++;
+		}
+		op = p[1];
+
+		/* Plus and minus are binary (not unary) _only_ if the last
+		 * token was as number, or a right paren (which pretends to be
+		 * a number, since it evaluates to one). Think about it.
+		 * It makes sense. */
+		if (lasttok != TOK_NUM) {
+			if(op == TOK_ADD)
+			    op = TOK_UPLUS;
+			else if(op == TOK_SUB)
+			    op = TOK_UMINUS;
+		}
+		/* We don't want a unary operator to cause recursive descent on the
+		 * stack, because there can be many in a row and it could cause an
+		 * operator to be evaluated before its argument is pushed onto the
+		 * integer stack. */
+		/* But for binary operators, "apply" everything on the operator
+		 * stack until we find an operator with a lesser priority than the
+		 * one we have just extracted. */
+		/* Left paren is given the lowest priority so it will never be
+		 * "applied" in this way.
+		 * if associativity is right and priority eq, applied also skip
+		 */
+		prec = PREC(op);
+		if ((prec > 0 && prec < UNARYPREC) || prec == SPEC_PREC) {
+			/* not left paren or unary */
+			if (lasttok != TOK_NUM) {
+				/* binary op must be preceded by a num */
+				goto err;
+			}
+			while (stackptr != stack) {
+			    if (op == TOK_RPAREN) {
+				/* The algorithm employed here is simple: while we don't
+				 * hit an open paren nor the bottom of the stack, pop
+				 * tokens and apply them */
+				if (stackptr[-1] == TOK_LPAREN) {
+				    --stackptr;
+				    /* Any operator directly after a */
+				    lasttok = TOK_NUM;
+				    /* close paren should consider itself binary */
+				    goto prologue;
+				}
+			    } else {
+				operator prev_prec = PREC(stackptr[-1]);
+
+				if (prev_prec < prec)
+					break;
+				/* check right assoc */
+				if(prev_prec == prec && prec == PREC(TOK_CONDITIONAL))
+					break;
+			    }
+			    errcode = arith_apply(*--stackptr, numstack, &numstackptr);
+			    if(errcode) goto ret;
+			}
+			if (op == TOK_RPAREN) {
+				goto err;
+			}
+		}
+
+		/* Push this operator to the stack and remember it. */
+		*stackptr++ = lasttok = op;
+
+	  prologue:
+		++expr;
+	}
+    }
+}
+
+/* stupid C lexical analyser for configs.h */
+static void c_lex_config(const char *fname, long fsize)
 {
   int c;
   int state;
   int line;
   char *id = id_s;
-  size_t id_len = 0;                /* stupid initialization */
+  size_t id_len = 0;                /* stupid initialize */
   unsigned char *optr, *oend;
+  int mode = CONFIG_MODE;
 
   int fd;
   char *map;
@@ -242,6 +768,8 @@ static void c_lex(const char *fname, long fsize)
 			/* <S><<EOF>> */
 			munmap(map, mapsize);
 			close(fd);
+			if(mode != CONFIG_MODE)
+				yy_error_d("expected #endif");
 			return;
 		}
 		if(c == REM) {
@@ -282,7 +810,7 @@ static void c_lex(const char *fname, long fsize)
 
 			/* trick for fast drop id
 			   if key with this first char undefined */
-			if(first_chars[c] == 0) {
+			if(first_chars[c] == 0 || (mode & FALSE_MODES) != 0) {
 			    /* skip <S>[A-Z_a-z0-9]+ */
 			    do getc1(); while(isalnums[c]);
 			} else {
@@ -314,30 +842,37 @@ static void c_lex(const char *fname, long fsize)
 	}
 	if(state == POUND) {
 	    /* tricks */
-	    static const char * const preproc[] = {
-		    /* 0 1   2  3     4        5        6 */
-		    "", "", "", "", "ndef", "efine", "nclude"
-	    };
-	    size_t diu = first_chars_diu[c];   /* strlen and preproc ptr */
+	    int diu = (int)first_chars_deiu[c];   /* preproc ptr */
 
 	    state = S;
 	    if(diu != S) {
+		int p_num_str, p_num_max;
+
 		getc1();
 		id_len = 0;
 		while(isalnums[c]) {
 		    put_id(c);
 		    getc1();
 		}
-		/* str begins with c, read == strlen key and compared */
-		if(diu == id_len && !memcmp(id, preproc[diu], diu)) {
-		    state = diu + '0';
-		    id_len = 0; /* common for save */
+		put_id(0);
+		p_num_str = diu & 0xf;
+		p_num_max = diu >> 4;
+		for(diu = p_num_str; diu <= p_num_max; diu++)
+		    if(!strcmp(id, preproc[diu])) {
+			state = (diu + '0');
+			/* common */
+			id_len = 0;
+			break;
 		}
 	    } else {
 		while(isalnums[c]) getc1();
 	    }
+	} else if(state == EF) {
+		/* #endif */
+		pop_mode();
+		state = S;
 	} else if(state == I) {
-		if(c == STR) {
+		if(c == STR && (mode & FALSE_MODES) == 0) {
 			/* <I>\" */
 			for(;;) {
 			    getc1();
@@ -354,31 +889,84 @@ static void c_lex(const char *fname, long fsize)
 		}
 		/* else another (may be wrong) #include ... */
 		state = S;
+	} else if(state == F) {
+	    arith_t t;
+	    int errcode;
+
+	    while(c != '\n' && c != L_EOF) {
+		put_id(c);
+		getc1();
+	    }
+	    put_id(0);
+	    t = arith(id, &errcode);
+	    if (errcode < 0) {
+		if (errcode == -2)
+		    yy_error_d("divide by zero");
+		else if (errcode == -4)
+		    yy_error_d("undefined");
+		else if (errcode == -5)
+		    yy_error_d("expression recursion loop detected");
+		else
+		    yy_error_d("syntax error");
+	    }
+	    push_mode();
+	    mode = t != 0 ? IF1_MODE : IF0_MODE;
+	    state = S;
+	} else if(state == IFD || state == IFND) {
+	    /* save KEY from #if(n)def KEY ... */
+	    const char *v;
+
+	    push_mode();
+	    while(isalnums[c]) {
+		put_id(c);
+		getc1();
+	    }
+	    if(!id_len)
+		yy_error_d("expected identifier");
+	    v = lookup_key(id, id_len);
+	    mode = IF1_MODE;
+	    if(state == IFD && v == NULL)
+		mode = IF0_MODE;
+	    else if(state == IFND && v != NULL)
+		    mode = IF0_MODE;
+	    state = S;
+	} else if(state == EI) {
+	    /* #elif */
+	    if(mode == CONFIG_MODE || mode == ELSE0_MODE || mode == ELSE1_MODE)
+		yy_error_d("unexpected #elif");
+	    if(mode == IF0_MODE) {
+		pop_mode();
+		state = F;
+	    } else {
+		mode = ELIF1_MODE;
+		state = S;
+	    }
+	} else if(state == E) {
+	    if(mode == CONFIG_MODE || mode == ELSE0_MODE || mode == ELSE1_MODE)
+		yy_error_d("unexpected #else");
+	    if(mode == IF0_MODE)
+		mode = ELSE0_MODE;
+	    else if(mode == IF1_MODE)
+		mode = ELSE1_MODE;
+	    state = S;
 	} else if(state == D || state == U) {
-	    if(mode == SOURCES_MODE) {
-		/* ignore depend with #define or #undef KEY */
-		while(isalnums[c]) getc1();
+	    /* save KEY from #"define"|"undef" ... */
+	    while(isalnums[c]) {
+		put_id(c);
+		getc1();
+	    }
+	    if(!id_len)
+		yy_error_d("expected identifier");
+	    if(state == U) {
+		if((mode & FALSE_MODES) == 0)
+		    parse_conf_opt(id, NULL, id_len);
 		state = S;
 	    } else {
-		/* save KEY from #"define"|"undef" ... */
-		while(isalnums[c]) {
-		    put_id(c);
-		    getc1();
-		}
-		if(!id_len)
-		    yy_error_d("expected identifier");
-		if(state == U) {
-		    parse_conf_opt(id, NULL, id_len);
-		    state = S;
-		} else {
-		    /* D -> DK */
-		    if(c == '(')
-			yy_error_d("unexpected function macro");
-		    state = DK;
-		}
+		/* D -> DK */
+		state = DK;
 	    }
 	} else {
-	    /* state==<DK> #define KEY[ ] (config mode) */
+	    /* state==<DK> #define KEY[ ] */
 	    size_t opt_len = id_len;
 	    char *val = id + opt_len;
 	    char *sp;
@@ -395,7 +983,8 @@ static void c_lex(const char *fname, long fsize)
 	    while(--sp >= val && (*sp == ' ' || *sp == '\t'
 				|| *sp == '\f' || *sp == '\v'))
 		*sp = '\0';
-	    parse_conf_opt(id, val, opt_len);
+	    if((mode & FALSE_MODES) == 0)
+		parse_conf_opt(id, val, opt_len);
 	    state = S;
 	}
     }
@@ -426,8 +1015,219 @@ too_long:
   yy_error_d("phrase too long");
 }
 
+/* trick for fast find "define", "include", "undef" */
+static const char first_chars_diu[UCHAR_MAX] = {
+	[(int)'d'] = (char)5,           /* strlen("define")  - 1; */
+	[(int)'i'] = (char)6,           /* strlen("include") - 1; */
+	[(int)'u'] = (char)4,           /* strlen("undef")   - 1; */
+};
+
+#undef D
+#undef I
+#undef U
+#define D      '5'      /* #define preprocessor's directive */
+#define I      '6'      /* #include preprocessor's directive */
+#define U      '4'      /* #undef preprocessor's directive */
+
+/* stupid C lexical analyser for sources */
+static void c_lex_src(const char *fname, long fsize)
+{
+  int c;
+  int state;
+  int line;
+  char *id = id_s;
+  size_t id_len = 0;                /* stupid initialize */
+  unsigned char *optr, *oend;
+
+  int fd;
+  char *map;
+  int mapsize;
 
-/* bb_simplify_path special variant for absolute pathname */
+  if(fsize == 0) {
+    fprintf(stderr, "Warning: %s is empty\n", fname);
+    return;
+  }
+  fd = open(fname, O_RDONLY);
+  if(fd < 0) {
+	perror(fname);
+	return;
+  }
+  mapsize = (fsize+pagesizem1) & ~pagesizem1;
+  map = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, fd, 0);
+  if ((long) map == -1)
+	bb_error_d("%s: mmap: %m", fname);
+
+  optr = (unsigned char *)map;
+  oend = optr + fsize;
+
+  line = 1;
+  state = S;
+
+  for(;;) {
+    getc1();
+    for(;;) {
+	/* [ \t]+ eat first space */
+	while(c == ' ' || c == '\t')
+	    getc1();
+
+	if(state == S) {
+		while(first_chars[c] == ANY) {
+		    /* <S>unparsed */
+		    if(c == '\n')
+			line++;
+		    getc1();
+		}
+		if(c == L_EOF) {
+			/* <S><<EOF>> */
+			munmap(map, mapsize);
+			close(fd);
+			return;
+		}
+		if(c == REM) {
+			/* <S>/ */
+			getc0();
+			if(c == REM) {
+				/* <S>"//"[^\n]* */
+				do getc0(); while(c != '\n' && c != L_EOF);
+			} else if(c == '*') {
+				/* <S>[/][*] goto parse block comments */
+				break;
+			}
+		} else if(c == POUND) {
+			/* <S># */
+			state = c;
+			getc1();
+		} else if(c == STR || c == CHR) {
+			/* <S>\"|\' */
+			int qc = c;
+
+			for(;;) {
+			    /* <STR,CHR>. */
+			    getc1();
+			    if(c == qc) {
+				/* <STR>\" or <CHR>\' */
+				break;
+			    }
+			    if(c == BS) {
+				/* <STR,CHR>\\ but is not <STR,CHR>\\\n */
+				getc0();
+			    }
+			    if(c == '\n' || c == L_EOF)
+				yy_error_d("unterminated");
+			}
+			getc1();
+		} else {
+			/* <S>[A-Z_a-z0-9] */
+
+			/* trick for fast drop id
+			   if key with this first char undefined */
+			if(first_chars[c] == 0) {
+			    /* skip <S>[A-Z_a-z0-9]+ */
+			    do getc1(); while(isalnums[c]);
+			} else {
+			    id_len = 0;
+			    do {
+				/* <S>[A-Z_a-z0-9]+ */
+				put_id(c);
+				getc1();
+			    } while(isalnums[c]);
+			    check_key(key_top, id, id_len);
+			}
+		}
+		continue;
+	}
+	/* begin preprocessor states */
+	if(c == L_EOF)
+	    yy_error_d("unexpected EOF");
+	if(c == REM) {
+		/* <#.*>/ */
+		getc0();
+		if(c == REM)
+			yy_error_d("detected // in preprocessor line");
+		if(c == '*') {
+			/* <#.*>[/][*] goto parse block comments */
+			break;
+		}
+		/* hmm, #.*[/] */
+		yy_error_d("strange preprocessor line");
+	}
+	if(state == POUND) {
+	    /* tricks */
+	    static const char * const p_preproc[] = {
+		    /* 0 1   2  3     4        5        6 */
+		    "", "", "", "", "ndef", "efine", "nclude"
+	    };
+	    size_t diu = first_chars_diu[c];   /* strlen and p_preproc ptr */
+
+	    state = S;
+	    if(diu != S) {
+		getc1();
+		id_len = 0;
+		while(isalnums[c]) {
+		    put_id(c);
+		    getc1();
+		}
+		/* have str begined with c, readed == strlen key and compared */
+		if(diu == id_len && !memcmp(id, p_preproc[diu], diu)) {
+		    state = diu + '0';
+		    id_len = 0; /* common for save */
+		}
+	    } else {
+		while(isalnums[c]) getc1();
+	    }
+	} else if(state == I) {
+		if(c == STR) {
+			/* <I>\" */
+			for(;;) {
+			    getc1();
+			    if(c == STR)
+				break;
+			    if(c == L_EOF)
+				yy_error_d("unexpected EOF");
+			    put_id(c);
+			}
+			put_id(0);
+			/* store "include.h" */
+			parse_inc(id, fname);
+			getc1();
+		}
+		/* else another (may be wrong) #include ... */
+		state = S;
+	} else /* if(state == D || state == U) */ {
+		/* ignore depend with #define or #undef KEY */
+		while(isalnums[c]) getc1();
+		state = S;
+	}
+    }
+
+    /* <REM> */
+    getc0();
+    for(;;) {
+	  /* <REM>[^*]+ */
+	  while(c != '*') {
+		if(c == '\n') {
+		    /* <REM>\n */
+		    if(state != S)
+			yy_error_d("unexpected newline");
+		    line++;
+		} else if(c == L_EOF)
+		    yy_error_d("unexpected EOF");
+		getc0();
+	  }
+	  /* <REM>[*] */
+	  getc0();
+	  if(c == REM) {
+		/* <REM>[*][/] */
+		break;
+	  }
+    }
+  }
+too_long:
+  yy_error_d("phrase too long");
+}
+
+
+/* bb_simplify_path special variant for apsolute pathname */
 static size_t bb_qa_simplify_path(char *path)
 {
 	char *s, *p;
@@ -477,7 +1277,7 @@ static void parse_inc(const char *include, const char *fname)
 	const char *p;
 
 	lo = Iop;
-	p = strrchr(fname, '/');    /* fname has absolute pathname */
+	p = strrchr(fname, '/');    /* fname have absolute pathname */
 	w = (p-fname);
 	/* find from current directory of source file */
 	ap = bb_asprint("%.*s/%s", w, fname, include);
@@ -502,14 +1302,15 @@ static void parse_inc(const char *include, const char *fname)
 
 	/* find from "-I include" specified directories */
 	free(ap);
-	/* lo->data has absolute pathname */
+	/* lo->data have absolute pathname */
 	ap = bb_asprint("%s/%s", lo->data, include);
 	lo = lo->link;
     }
 
     cur = xmalloc(sizeof(bb_key_t));
-    cur->keyname = cur->stored_path = ap;
+    cur->keyname = ap;
     cur->key_sz = key_sz;
+    cur->stored_path = ap;
     cur->value = cur->checked = p_i;
     if(p_i == NULL && noiwarning)
 	fprintf(stderr, "%s: Warning: #include \"%s\" not found\n", fname, include);
@@ -528,7 +1329,7 @@ static void parse_conf_opt(const char *opt, const char *val, size_t key_sz)
 
 	cur = check_key(key_top, opt, key_sz);
 	if(cur != NULL) {
-	    /* already present */
+	    /* present already */
 	    cur->checked = NULL;        /* store only */
 	    if(cur->value == NULL && val == NULL)
 		return;
@@ -568,7 +1369,7 @@ static void parse_conf_opt(const char *opt, const char *val, size_t key_sz)
 	first_chars[(int)*k] = *k;
 
 	cur->stored_path = k = bb_asprint("%s/%s.h", kp, k);
-	/* key conversion [A-Z_] -> [a-z/] */
+	/* key converting [A-Z_] -> [a-z/] */
 	for(p = k + kp_len + 1; *p; p++) {
 	    if(*p >= 'A' && *p <= 'Z')
 		    *p = *p - 'A' + 'a';
@@ -604,7 +1405,7 @@ static void store_keys(void)
 	    }
 	    /* size_t -> ssize_t :( */
 	    rw_ret = (ssize_t)recordsz;
-	    /* check kp/key.h, compare after previous use */
+	    /* check kp/key.h, compare after previous usage */
 	    cmp_ok = 0;
 	    k = cur->stored_path;
 	    if(stat(k, &st)) {
@@ -709,7 +1510,7 @@ parse_chd(const char *fe, const char *p, size_t dirlen)
 	    }
 	}
 	/* direntry is *.[ch] regular file and is not configs */
-	c_lex(fp, st.st_size);
+	c_lex_src(fp, st.st_size);
 	if(!dontgenerate_dep) {
 	    int first;
 	    if(*e == 'c') {
@@ -740,7 +1541,7 @@ parse_chd(const char *fe, const char *p, size_t dirlen)
     return NULL;
 }
 
-/* from libbb but inlined for speed considerations */
+/* from libbb but inline for fast */
 static inline llist_t *llist_add_to(llist_t *old_head, char *new_item)
 {
 	llist_t *new_head;
@@ -763,7 +1564,7 @@ static void scan_dir_find_ch_files(const char *p)
 
     dirs = llist_add_to(NULL, bb_simplify_path(p));
     replace = strlen(dirs->data);
-    /* emulate recursion */
+    /* emulate recursive */
     while(dirs) {
 	d_add = NULL;
 	while(dirs) {
@@ -803,7 +1604,7 @@ int main(int argc, char **argv)
 	llist_t *fl;
 
 	{
-	    /* for bb_simplify_path, this program has no chdir() */
+	    /* for bb_simplify_path, this program have not chdir() */
 	    /* libbb-like my xgetcwd() */
 	    unsigned path_max = 512;
 
@@ -863,7 +1664,7 @@ int main(int argc, char **argv)
 	for(i = 0; i < UCHAR_MAX; i++) {
 	    if(ISALNUM(i))
 		isalnums[i] = i;
-	    /* set unparsed chars to speed up the parser */
+	    /* set unparsed chars for speed up of parser */
 	    else if(i != CHR && i != STR && i != POUND && i != REM)
 		first_chars[i] = ANY;
 	}
@@ -875,7 +1676,7 @@ int main(int argc, char **argv)
 
 	    if(stat(fl->data, &st))
 		bb_error_d("stat(%s): %m", fl->data);
-	    c_lex(fl->data, st.st_size);
+	    c_lex_config(fl->data, st.st_size);
 	    free(fl->data);
 	    /* trick for fast comparing found files with configs */
 	    fl->data = xmalloc(sizeof(struct stat));
@@ -883,7 +1684,6 @@ int main(int argc, char **argv)
 	}
 
 	/* main loop */
-	mode = SOURCES_MODE;
 	argv += optind;
 	if(*argv) {
 	    while(*argv)
@@ -923,6 +1723,7 @@ static char *bb_asprint(const char *format, ...)
 }
 
 /* partial libbb routine as is */
+
 static char *bb_simplify_path(const char *path)
 {
 	char *s, *start, *p;
@@ -930,7 +1731,7 @@ static char *bb_simplify_path(const char *path)
 	if (path[0] == '/')
 		start = bb_xstrdup(path);
 	else {
-		/* is not libbb, but this program has no chdir() */
+		/* is not libbb, but this program have not chdir() */
 		start = bb_asprint("%s/%s", pwd, path);
 	}
 	p = s = start;