scripts/bb_mkdep.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Another fast dependencies generator for Makefiles, Version 4.2
   4  *
   5  * Copyright (C) 2005,2006 by Vladimir Oleynik <dzo@simtreas.ru>
   6  *
   7  * mmaping file may be originally by Linus Torvalds.
   8  *
   9  * infix parser/evaluator for #if expression
  10  *      Copyright (c) 2001 Aaron Lehmann <aaronl@vitelus.com>
  11  *      Copyright (c) 2001 Manuel Novoa III <mjn3@codepoet.org>
  12  *      Copyright (c) 2003 Vladimir Oleynik <dzo@simtreas.ru>
  13  *
  14  * bb_simplify_path()
  15  *      Copyright (C) 2005 Manuel Novoa III <mjn3@codepoet.org>
  16  *
  17  * xmalloc() bb_xstrdup() bb_error_d():
  18  *      Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
  19  *
  20  * llist routine
  21  *      Copyright (C) 2003 Glenn McGrath
  22  *      Copyright (C) Vladimir Oleynik <dzo@simtreas.ru>
  23  *
  24  * (c) 2005,2006 Bernhard Fischer:
  25  *  - commentary typos,
  26  *  - move "memory exhausted" into msg_enomem,
  27  *  - more verbose --help output.
  28  *
  29  * This program does:
  30  * 1) find #define KEY VALUE or #undef KEY from include/bb_config.h
  31  * 2) recursive find and scan *.[ch] files, but skips scan of include/config/
  32  * 3) find #include "*.h" and KEYs using, if not as #define and #undef
  33  * 4) generate dependencies to stdout
  34  *    pwd/file.o: include/config/key*.h found_include_*.h
  35  *    path/inc.h: include/config/key*.h found_included_include_*.h
  36  * 5) save include/config/key*.h if changed after previous usage
  37  * This program does not generate dependencies for #include <...>
  38  * Config file can have #if #elif #else #ifdef #ifndef #endif lines
  39  */
  40
  41 #define LOCAL_INCLUDE_PATH          "include"
  42 #define INCLUDE_CONFIG_PATH         LOCAL_INCLUDE_PATH"/config"
  43 #define INCLUDE_CONFIG_KEYS_PATH    LOCAL_INCLUDE_PATH"/bb_config.h"
  44
  45 #define bb_mkdep_full_options \
  46 "\nOptions:" \
  47 "\n\t-I local_include_path  include paths, default: \"" LOCAL_INCLUDE_PATH "\"" \
  48 "\n\t-d                     don't generate depend" \
  49 "\n\t-w                     show warning if include files not found" \
  50 "\n\t-k include/config      default: \"" INCLUDE_CONFIG_PATH "\"" \
  51 "\n\t-c include/config.h    configs, default: \"" INCLUDE_CONFIG_KEYS_PATH "\"" \
  52 "\n\tdirs_to_scan           default \".\""
  53
  54 #define bb_mkdep_terse_options "Usage: [-I local_include_paths] [-dw] " \
  55                    "[-k path_for_stored_keys] [dirs]"
  56
  57
  58 #define _GNU_SOURCE
  59 #include <sys/types.h>
  60 #include <sys/stat.h>
  61 #include <sys/mman.h>
  62 #include <getopt.h>
  63 #include <dirent.h>
  64 #include <stdio.h>
  65 #include <stdlib.h>
  66 #include <string.h>
  67 #include <stdarg.h>
  68 #include <unistd.h>
  69 #include <errno.h>
  70 #include <fcntl.h>
  71 #include <limits.h>
  72
  73 #ifdef __GNUC__
  74 #define ATTRIBUTE __attribute__
  75 #else
  76 #define ATTRIBUTE(a) /* nothing */
  77 #endif
  78
  79 #if !(defined __USE_ISOC99 || (defined __GLIBC_HAVE_LONG_LONG && defined __USE_MISC))
  80 #define strtoll strtol
  81 #endif
  82
  83 /* partial and simplified libbb routine */
  84 static void bb_error_d(const char *s, ...) ATTRIBUTE ((noreturn, format (printf, 1, 2)));
  85 static char * bb_asprint(const char *format, ...) ATTRIBUTE ((format (printf, 1, 2)));
  86 static char *bb_simplify_path(const char *path);
  87
  88 /* stolen from libbb as is */
  89 typedef struct llist_s {
  90         char *data;
  91         struct llist_s *link;
  92 } llist_t;
  93
  94 static const char msg_enomem[] = "memory exhausted";
  95
  96 /* inline realization for fast works */
  97 static inline void *xmalloc(size_t size)
  98 {
  99         void *p = malloc(size);
 100
 101         if(p == NULL)
 102                 bb_error_d(msg_enomem);
 103         return p;
 104 }
 105
 106 static inline char *bb_xstrdup(const char *s)
 107 {
 108         char *r = strdup(s);
 109
 110         if(r == NULL)
 111             bb_error_d(msg_enomem);
 112         return r;
 113 }
 114
 115
 116 static int dontgenerate_dep;    /* flag -d usaged */
 117 static int noiwarning;          /* flag -w usaged */
 118 static llist_t *configs;    /* list of -c usaged and them stat() after parsed */
 119 static llist_t *Iop;        /* list of -I include usaged */
 120
 121 static char *pwd;           /* current work directory */
 122 static size_t replace;      /* replace current work directory with build dir */
 123
 124 static const char *kp;      /* KEY path, argument of -k used */
 125 static size_t kp_len;
 126 static struct stat st_kp;   /* stat(kp) */
 127
 128 typedef struct BB_KEYS {
 129         char *keyname;
 130         size_t key_sz;
 131         const char *value;
 132         const char *checked;
 133         char *stored_path;
 134         const char *src_have_this_key;
 135         struct BB_KEYS *next;
 136 } bb_key_t;
 137
 138 static bb_key_t *key_top;   /* list of found KEYs */
 139 static bb_key_t *Ifound;    /* list of parsed includes */
 140
 141
 142 static void parse_conf_opt(const char *opt, const char *val, size_t key_sz);
 143 static void parse_inc(const char *include, const char *fname);
 144
 145 static inline bb_key_t *check_key(bb_key_t *k, const char *nk, size_t key_sz)
 146 {
 147     bb_key_t *cur;
 148
 149     for(cur = k; cur; cur = cur->next) {
 150         if(key_sz == cur->key_sz && memcmp(cur->keyname, nk, key_sz) == 0) {
 151             cur->checked = cur->stored_path;
 152             return cur;
 153         }
 154     }
 155     return NULL;
 156 }
 157
 158 static inline const char *lookup_key(const char *nk, size_t key_sz)
 159 {
 160     bb_key_t *cur;
 161
 162     for(cur = key_top; cur; cur = cur->next) {
 163         if(key_sz == cur->key_sz && memcmp(cur->keyname, nk, key_sz) == 0) {
 164             return cur->value;
 165         }
 166     }
 167     return NULL;
 168 }
 169
 170 /* for lexical analyser */
 171 static int pagesizem1;      /* padding mask = getpagesize() - 1 */
 172
 173 /* for speed tricks */
 174 static char first_chars[1+UCHAR_MAX];               /* + L_EOF */
 175 static char isalnums[1+UCHAR_MAX];                  /* + L_EOF */
 176
 177 /* trick for fast find "define", "include", "undef",
 178 "if((n)def)" "else", "endif"  */
 179 static const char * const preproc[] = {
 180 /* 0   1       2      3       4     5       6        7         8      9 */
 181 "", "efine", "lif", "lse", "ndif", "f", "fdef", "fndef", "nclude", "ndef" };
 182 static const unsigned char first_chars_deiu[UCHAR_MAX] = {
 183         [(int)'d'] = (unsigned char)(1|0x10),     /* define */
 184         [(int)'e'] = (unsigned char)(2|0x40),     /* elif, else, endif  */
 185         [(int)'i'] = (unsigned char)(5|0x80),     /* if ifdef ifndef include */
 186         [(int)'u'] = (unsigned char)(9|0x90),     /* undef */
 187 };
 188
 189 #define CONFIG_MODE  0
 190 #define IF0_MODE     1  /* #if 0  */
 191 #define IF1_MODE     2  /* #if 1 */
 192 #define ELSE0_MODE   4  /* #else found after #if 0 */
 193 #define ELSE1_MODE   8  /* #else found after #if 1 */
 194 #define ELIF1_MODE   16 /* #elif found after #if 1 */
 195 #define FALSE_MODES  (IF0_MODE|ELSE1_MODE|ELIF1_MODE)
 196
 197 #define yy_error_d(s) bb_error_d("%s:%d hmm, %s", fname, line, s)
 198
 199 /* state */
 200 #define S      0        /* start state */
 201 #define STR    '"'      /* string */
 202 #define CHR    '\''     /* char */
 203 #define REM    '/'      /* block comment */
 204 #define BS     '\\'     /* back slash */
 205 #define POUND  '#'      /* # */
 206 #define D      '1'      /* #define preprocessor's directive */
 207 #define EI     '2'      /* #elif preprocessor's directive */
 208 #define E      '3'      /* #else preprocessor's directive */
 209 #define EF     '4'      /* #endif preprocessor's directive */
 210 #define F      '5'      /* #if preprocessor's directive */
 211 #define IFD    '6'      /* #ifdef preprocessor's directive */
 212 #define IFND   '7'      /* #ifndef preprocessor's directive */
 213 #define I      '8'      /* #include preprocessor's directive */
 214 #define U      '9'      /* #undef preprocessor's directive */
 215 #define DK     'K'      /* #define KEY... (config mode) */
 216 #define ANY    '*'      /* any unparsed chars */
 217
 218 /* [A-Z_a-z] */
 219 #define ID(c) ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
 220 /* [A-Z_a-z0-9] */
 221 #define ISALNUM(c)  (ID(c) || (c >= '0' && c <= '9'))
 222
 223 #define L_EOF  (1+UCHAR_MAX)
 224
 225 #define getc0()     do { c = (optr >= oend) ? L_EOF : *optr++; } while(0)
 226
 227 #define getc1()     do { getc0(); if(c == BS) { getc0(); \
 228                                     if(c == '\n') { line++; continue; } \
 229                                     else { optr--; c = BS; } \
 230                                   } break; } while(1)
 231
 232 static char id_s[4096];
 233 #define put_id(ic)  do {    if(id_len == sizeof(id_s)) goto too_long; \
 234                                 id[id_len++] = ic; } while(0)
 235
 236 static char ifcpp_stack[1024];
 237 static int  ptr_ifcpp_stack;
 238 #define push_mode() do { \
 239                         if(ptr_ifcpp_stack == (int)sizeof(ifcpp_stack)) \
 240                                 yy_error_d("#if* stack overflow"); \
 241                         ifcpp_stack[ptr_ifcpp_stack++] = (char)mode; \
 242                         } while(0)
 243
 244 #define pop_mode()  do { \
 245                         if(ptr_ifcpp_stack == 0) \
 246                                 yy_error_d("unexpected #endif"); \
 247                         mode = ifcpp_stack[--ptr_ifcpp_stack]; \
 248                         } while(0)
 249
 250 /* #if expression */
 251 typedef long long arith_t;
 252
 253 static arith_t arith (const char *expr, int *perrcode);
 254
 255 /* The code uses a simple two-stack algorithm. See
 256  * http://www.onthenet.com.au/~grahamis/int2008/week02/lect02.html
 257  * for a detailed explanation of the infix-to-postfix algorithm on which
 258  * this is based (this code differs in that it applies operators immediately
 259  * to the stack instead of adding them to a queue to end up with an
 260  * expression). */
 261
 262 #define arith_isspace(arithval) \
 263         (arithval == ' ' || arithval == '\v' || arithval == '\t' || arithval == '\f')
 264
 265
 266 typedef unsigned char operator;
 267
 268 /* An operator's token id is a bit of a bitfield. The lower 5 bits are the
 269  * precedence, and 3 high bits are an ID unique across operators of that
 270  * precedence. The ID portion is so that multiple operators can have the
 271  * same precedence, ensuring that the leftmost one is evaluated first.
 272  * Consider * and /. */
 273
 274 #define tok_decl(prec,id) (((id)<<5)|(prec))
 275 #define PREC(op) ((op) & 0x1F)
 276
 277 #define TOK_LPAREN tok_decl(0,0)
 278
 279 #define TOK_COMMA tok_decl(1,0)
 280
 281 /* conditional is right associativity too */
 282 #define TOK_CONDITIONAL tok_decl(2,0)
 283 #define TOK_CONDITIONAL_SEP tok_decl(2,1)
 284
 285 #define TOK_OR tok_decl(3,0)
 286
 287 #define TOK_AND tok_decl(4,0)
 288
 289 #define TOK_BOR tok_decl(5,0)
 290
 291 #define TOK_BXOR tok_decl(6,0)
 292
 293 #define TOK_BAND tok_decl(7,0)
 294
 295 #define TOK_EQ tok_decl(8,0)
 296 #define TOK_NE tok_decl(8,1)
 297
 298 #define TOK_LT tok_decl(9,0)
 299 #define TOK_GT tok_decl(9,1)
 300 #define TOK_GE tok_decl(9,2)
 301 #define TOK_LE tok_decl(9,3)
 302
 303 #define TOK_LSHIFT tok_decl(10,0)
 304 #define TOK_RSHIFT tok_decl(10,1)
 305
 306 #define TOK_ADD tok_decl(11,0)
 307 #define TOK_SUB tok_decl(11,1)
 308
 309 #define TOK_MUL tok_decl(12,0)
 310 #define TOK_DIV tok_decl(12,1)
 311 #define TOK_REM tok_decl(12,2)
 312
 313 /* For now unary operators. */
 314 #define UNARYPREC 13
 315 #define TOK_BNOT tok_decl(UNARYPREC,0)
 316 #define TOK_NOT tok_decl(UNARYPREC,1)
 317
 318 #define TOK_UMINUS tok_decl(UNARYPREC+1,0)
 319 #define TOK_UPLUS tok_decl(UNARYPREC+1,1)
 320
 321 #define SPEC_PREC (UNARYPREC+2)
 322
 323 #define TOK_NUM tok_decl(SPEC_PREC, 0)
 324 #define TOK_RPAREN tok_decl(SPEC_PREC, 1)
 325
 326 #define NUMPTR (*numstackptr)
 327
 328 typedef struct ARITCH_VAR_NUM {
 329         arith_t val;
 330         arith_t contidional_second_val;
 331         char contidional_second_val_initialized;
 332 } v_n_t;
 333
 334
 335 typedef struct CHK_VAR_RECURSIVE_LOOPED {
 336         const char *var;
 337         size_t var_sz;
 338         struct CHK_VAR_RECURSIVE_LOOPED *next;
 339 } chk_var_recursive_looped_t;
 340
 341 static chk_var_recursive_looped_t *prev_chk_var_recursive;
 342
 343
 344 static int arith_lookup_val(const char *var, size_t key_sz, arith_t *pval)
 345 {
 346     const char * p = lookup_key(var, key_sz);
 347
 348     if(p) {
 349         int errcode;
 350
 351         /* recursive try as expression */
 352         chk_var_recursive_looped_t *cur;
 353         chk_var_recursive_looped_t cur_save;
 354
 355         for(cur = prev_chk_var_recursive; cur; cur = cur->next) {
 356             if(cur->var_sz == key_sz && memcmp(cur->var, var, key_sz) == 0) {
 357                 /* expression recursion loop detected */
 358                 return -5;
 359             }
 360         }
 361         /* save current lookuped var name */
 362         cur = prev_chk_var_recursive;
 363         cur_save.var = var;
 364         cur_save.var_sz = key_sz;
 365         cur_save.next = cur;
 366         prev_chk_var_recursive = &cur_save;
 367
 368         *pval = arith (p, &errcode);
 369         /* restore previous ptr after recursiving */
 370         prev_chk_var_recursive = cur;
 371         return errcode;
 372     } else {
 373         /* disallow undefined var */
 374         fprintf(stderr, "%.*s ", (int)key_sz, var);
 375         return -4;
 376     }
 377 }
 378
 379 /* "applying" a token means performing it on the top elements on the integer
 380  * stack. For a unary operator it will only change the top element, but a
 381  * binary operator will pop two arguments and push a result */
 382 static inline int
 383 arith_apply(operator op, v_n_t *numstack, v_n_t **numstackptr)
 384 {
 385         v_n_t *numptr_m1;
 386         arith_t numptr_val, rez;
 387
 388         if (NUMPTR == numstack) goto err; /* There is no operator that can work
 389                                                                                  without arguments */
 390         numptr_m1 = NUMPTR - 1;
 391
 392         rez = numptr_m1->val;
 393         if (op == TOK_UMINUS)
 394                 rez *= -1;
 395         else if (op == TOK_NOT)
 396                 rez = !rez;
 397         else if (op == TOK_BNOT)
 398                 rez = ~rez;
 399         else if (op != TOK_UPLUS) {
 400                 /* Binary operators */
 401
 402             /* check and binary operators need two arguments */
 403             if (numptr_m1 == numstack) goto err;
 404
 405             /* ... and they pop one */
 406             --NUMPTR;
 407             numptr_val = rez;
 408             if (op == TOK_CONDITIONAL) {
 409                 if(! numptr_m1->contidional_second_val_initialized) {
 410                     /* protect $((expr1 ? expr2)) without ": expr" */
 411                     goto err;
 412                 }
 413                 rez = numptr_m1->contidional_second_val;
 414             } else if(numptr_m1->contidional_second_val_initialized) {
 415                     /* protect $((expr1 : expr2)) without "expr ? " */
 416                     goto err;
 417             }
 418             numptr_m1 = NUMPTR - 1;
 419             if (op == TOK_CONDITIONAL) {
 420                     numptr_m1->contidional_second_val = rez;
 421             }
 422             rez = numptr_m1->val;
 423             if (op == TOK_BOR)
 424                         rez |= numptr_val;
 425             else if (op == TOK_OR)
 426                         rez = numptr_val || rez;
 427             else if (op == TOK_BAND)
 428                         rez &= numptr_val;
 429             else if (op == TOK_BXOR)
 430                         rez ^= numptr_val;
 431             else if (op == TOK_AND)
 432                         rez = rez && numptr_val;
 433             else if (op == TOK_EQ)
 434                         rez = (rez == numptr_val);
 435             else if (op == TOK_NE)
 436                         rez = (rez != numptr_val);
 437             else if (op == TOK_GE)
 438                         rez = (rez >= numptr_val);
 439             else if (op == TOK_RSHIFT)
 440                         rez >>= numptr_val;
 441             else if (op == TOK_LSHIFT)
 442                         rez <<= numptr_val;
 443             else if (op == TOK_GT)
 444                         rez = (rez > numptr_val);
 445             else if (op == TOK_LT)
 446                         rez = (rez < numptr_val);
 447             else if (op == TOK_LE)
 448                         rez = (rez <= numptr_val);
 449             else if (op == TOK_MUL)
 450                         rez *= numptr_val;
 451             else if (op == TOK_ADD)
 452                         rez += numptr_val;
 453             else if (op == TOK_SUB)
 454                         rez -= numptr_val;
 455             else if (op == TOK_COMMA)
 456                         rez = numptr_val;
 457             else if (op == TOK_CONDITIONAL_SEP) {
 458                         if (numptr_m1 == numstack) {
 459                             /* protect $((expr : expr)) without "expr ? " */
 460                             goto err;
 461                         }
 462                         numptr_m1->contidional_second_val_initialized = op;
 463                         numptr_m1->contidional_second_val = numptr_val;
 464             }
 465             else if (op == TOK_CONDITIONAL) {
 466                         rez = rez ?
 467                               numptr_val : numptr_m1->contidional_second_val;
 468             }
 469             else if(numptr_val==0)          /* zero divisor check */
 470                         return -2;
 471             else if (op == TOK_DIV)
 472                         rez /= numptr_val;
 473             else if (op == TOK_REM)
 474                         rez %= numptr_val;
 475         }
 476         numptr_m1->val = rez;
 477         return 0;
 478 err: return(-1);
 479 }
 480
 481 /* longest must first */
 482 static const char op_tokens[] = {
 483         '<','<',    0, TOK_LSHIFT,
 484         '>','>',    0, TOK_RSHIFT,
 485         '|','|',    0, TOK_OR,
 486         '&','&',    0, TOK_AND,
 487         '!','=',    0, TOK_NE,
 488         '<','=',    0, TOK_LE,
 489         '>','=',    0, TOK_GE,
 490         '=','=',    0, TOK_EQ,
 491         '!',        0, TOK_NOT,
 492         '<',        0, TOK_LT,
 493         '>',        0, TOK_GT,
 494         '|',        0, TOK_BOR,
 495         '&',        0, TOK_BAND,
 496         '*',        0, TOK_MUL,
 497         '/',        0, TOK_DIV,
 498         '%',        0, TOK_REM,
 499         '+',        0, TOK_ADD,
 500         '-',        0, TOK_SUB,
 501         '^',        0, TOK_BXOR,
 502         '~',        0, TOK_BNOT,
 503         ',',        0, TOK_COMMA,
 504         '?',        0, TOK_CONDITIONAL,
 505         ':',        0, TOK_CONDITIONAL_SEP,
 506         ')',        0, TOK_RPAREN,
 507         '(',        0, TOK_LPAREN,
 508         0
 509 };
 510 /* ptr to ")" */
 511 #define endexpression &op_tokens[sizeof(op_tokens)-7]
 512
 513 /*
 514  * Return of a legal variable name (a letter or underscore followed by zero or
 515  * more letters, underscores, and digits).
 516  */
 517
 518 static inline char *
 519 endofname(const char *name)
 520 {
 521         char *p;
 522
 523         p = (char *) name;
 524         if (! ID(*p))
 525                 return p;
 526         while (*++p) {
 527                 if (! ISALNUM(*p))
 528                         break;
 529         }
 530         return p;
 531 }
 532
 533
 534 static arith_t arith (const char *expr, int *perrcode)
 535 {
 536     char arithval;          /* Current character under analysis */
 537     operator lasttok, op;
 538     operator prec;
 539
 540     const char *p = endexpression;
 541     int errcode;
 542
 543     size_t datasizes = strlen(expr) + 2;
 544
 545     /* Stack of integers */
 546     /* The proof that there can be no more than strlen(startbuf)/2+1 integers
 547      * in any given correct or incorrect expression is left as an exercise to
 548      * the reader. */
 549     v_n_t *numstack = alloca(((datasizes)/2)*sizeof(v_n_t)),
 550             *numstackptr = numstack;
 551     /* Stack of operator tokens */
 552     operator *stack = alloca((datasizes) * sizeof(operator)),
 553             *stackptr = stack;
 554
 555     *stackptr++ = lasttok = TOK_LPAREN;     /* start off with a left paren */
 556     *perrcode = errcode = 0;
 557
 558     while(1) {
 559         if ((arithval = *expr) == 0) {
 560                 if (p == endexpression) {
 561                         /* Null expression. */
 562 err:
 563                         return (*perrcode = -1);
 564                 }
 565
 566                 /* This is only reached after all tokens have been extracted from the
 567                  * input stream. If there are still tokens on the operator stack, they
 568                  * are to be applied in order. At the end, there should be a final
 569                  * result on the integer stack */
 570
 571                 if (expr != endexpression + 1) {
 572                         /* If we haven't done so already, */
 573                         /* append a closing right paren */
 574                         expr = endexpression;
 575                         /* and let the loop process it. */
 576                         continue;
 577                 }
 578                 /* At this point, we're done with the expression. */
 579                 if (numstackptr != numstack+1) {
 580                         /* ... but if there isn't, it's bad */
 581                         goto err;
 582                 }
 583         ret:
 584                 *perrcode = errcode;
 585                 return numstack->val;
 586         } else {
 587                 /* Continue processing the expression. */
 588                 if (arith_isspace(arithval)) {
 589                         /* Skip whitespace */
 590                         goto prologue;
 591                 }
 592                 if((p = endofname(expr)) != expr) {
 593                         size_t var_name_size = (p-expr);
 594
 595                         if(var_name_size == 7 &&
 596                                 strncmp(expr, "defined", var_name_size) == 0) {
 597                             int brace_form = 0;
 598                             const char *v;
 599
 600                             while(arith_isspace(*p)) p++;
 601                             if(*p == '(') {
 602                                 p++;
 603                                 while(arith_isspace(*p)) p++;
 604                                 brace_form = 1;
 605                             }
 606                             expr = p;
 607                             if((p = endofname(expr)) == expr)
 608                                 goto err;
 609                             var_name_size = (p-expr);
 610                             while(arith_isspace(*p)) p++;
 611                             if(brace_form && *p++ != ')')
 612                                 goto err;
 613                             v = lookup_key(expr, var_name_size);
 614                             numstackptr->val = (v != NULL) ? 1 : 0;
 615                         } else {
 616                             errcode = arith_lookup_val(expr, var_name_size,
 617                                         &(numstackptr->val));
 618                             if(errcode) goto ret;
 619                         }
 620                         expr = p;
 621                 num:
 622                         numstackptr->contidional_second_val_initialized = 0;
 623                         numstackptr++;
 624                         lasttok = TOK_NUM;
 625                         continue;
 626                 } else if (arithval >= '0' && arithval <= '9') {
 627                         numstackptr->val = strtoll(expr, (char **) &expr, 0);
 628                         while(*expr == 'l' || *expr == 'L' || *expr == 'u' ||
 629                                                                 *expr == 'U')
 630                             expr++;
 631                         goto num;
 632                 }
 633                 for(p = op_tokens; ; p++) {
 634                         const char *o;
 635
 636                         if(*p == 0) {
 637                                 /* strange operator not found */
 638                                 goto err;
 639                         }
 640                         for(o = expr; *p && *o == *p; p++)
 641                                 o++;
 642                         if(! *p) {
 643                                 /* found */
 644                                 expr = o - 1;
 645                                 break;
 646                         }
 647                         /* skip tail uncompared token */
 648                         while(*p)
 649                                 p++;
 650                         /* skip zero delim */
 651                         p++;
 652                 }
 653                 op = p[1];
 654
 655                 /* Plus and minus are binary (not unary) _only_ if the last
 656                  * token was as number, or a right paren (which pretends to be
 657                  * a number, since it evaluates to one). Think about it.
 658                  * It makes sense. */
 659                 if (lasttok != TOK_NUM) {
 660                         if(op == TOK_ADD)
 661                             op = TOK_UPLUS;
 662                         else if(op == TOK_SUB)
 663                             op = TOK_UMINUS;
 664                 }
 665                 /* We don't want a unary operator to cause recursive descent on the
 666                  * stack, because there can be many in a row and it could cause an
 667                  * operator to be evaluated before its argument is pushed onto the
 668                  * integer stack. */
 669                 /* But for binary operators, "apply" everything on the operator
 670                  * stack until we find an operator with a lesser priority than the
 671                  * one we have just extracted. */
 672                 /* Left paren is given the lowest priority so it will never be
 673                  * "applied" in this way.
 674                  * if associativity is right and priority eq, applied also skip
 675                  */
 676                 prec = PREC(op);
 677                 if ((prec > 0 && prec < UNARYPREC) || prec == SPEC_PREC) {
 678                         /* not left paren or unary */
 679                         if (lasttok != TOK_NUM) {
 680                                 /* binary op must be preceded by a num */
 681                                 goto err;
 682                         }
 683                         while (stackptr != stack) {
 684                             if (op == TOK_RPAREN) {
 685                                 /* The algorithm employed here is simple: while we don't
 686                                  * hit an open paren nor the bottom of the stack, pop
 687                                  * tokens and apply them */
 688                                 if (stackptr[-1] == TOK_LPAREN) {
 689                                     --stackptr;
 690                                     /* Any operator directly after a */
 691                                     lasttok = TOK_NUM;
 692                                     /* close paren should consider itself binary */
 693                                     goto prologue;
 694                                 }
 695                             } else {
 696                                 operator prev_prec = PREC(stackptr[-1]);
 697
 698                                 if (prev_prec < prec)
 699                                         break;
 700                                 /* check right assoc */
 701                                 if(prev_prec == prec && prec == PREC(TOK_CONDITIONAL))
 702                                         break;
 703                             }
 704                             errcode = arith_apply(*--stackptr, numstack, &numstackptr);
 705                             if(errcode) goto ret;
 706                         }
 707                         if (op == TOK_RPAREN) {
 708                                 goto err;
 709                         }
 710                 }
 711
 712                 /* Push this operator to the stack and remember it. */
 713                 *stackptr++ = lasttok = op;
 714
 715           prologue:
 716                 ++expr;
 717         }
 718     }
 719 }
 720
 721 /* stupid C lexical analyser for configs.h */
 722 static void c_lex_config(const char *fname, long fsize)
 723 {
 724   int c;
 725   int state;
 726   int line;
 727   char *id = id_s;
 728   size_t id_len = 0;                /* stupid initialization */
 729   unsigned char *optr, *oend;
 730   int mode = CONFIG_MODE;
 731
 732   int fd;
 733   char *map;
 734   int mapsize;
 735
 736   if(fsize == 0) {
 737     fprintf(stderr, "Warning: %s is empty\n", fname);
 738     return;
 739   }
 740   fd = open(fname, O_RDONLY);
 741   if(fd < 0) {
 742         perror(fname);
 743         return;
 744   }
 745   mapsize = (fsize+pagesizem1) & ~pagesizem1;
 746   map = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, fd, 0);
 747   if ((long) map == -1)
 748         bb_error_d("%s: mmap: %m", fname);
 749
 750   optr = (unsigned char *)map;
 751   oend = optr + fsize;
 752
 753   line = 1;
 754   state = S;
 755
 756   for(;;) {
 757     getc1();
 758     for(;;) {
 759         /* [ \t]+ eat first space */
 760         while(c == ' ' || c == '\t')
 761             getc1();
 762
 763         if(state == S) {
 764                 while(first_chars[c] == ANY) {
 765                     /* <S>unparsed */
 766                     if(c == '\n')
 767                         line++;
 768                     getc1();
 769                 }
 770                 if(c == L_EOF) {
 771                         /* <S><<EOF>> */
 772                         munmap(map, mapsize);
 773                         close(fd);
 774                         if(mode != CONFIG_MODE)
 775                                 yy_error_d("expected #endif");
 776                         return;
 777                 }
 778                 if(c == REM) {
 779                         /* <S>/ */
 780                         getc0();
 781                         if(c == REM) {
 782                                 /* <S>"//"[^\n]* */
 783                                 do getc0(); while(c != '\n' && c != L_EOF);
 784                         } else if(c == '*') {
 785                                 /* <S>[/][*] goto parse block comments */
 786                                 break;
 787                         }
 788                 } else if(c == POUND) {
 789                         /* <S># */
 790                         state = c;
 791                         getc1();
 792                 } else if(c == STR || c == CHR) {
 793                         /* <S>\"|\' */
 794                         int qc = c;
 795
 796                         for(;;) {
 797                             /* <STR,CHR>. */
 798                             getc1();
 799                             if(c == qc) {
 800                                 /* <STR>\" or <CHR>\' */
 801                                 break;
 802                             }
 803                             if(c == BS) {
 804                                 /* <STR,CHR>\\ but is not <STR,CHR>\\\n */
 805                                 getc0();
 806                             }
 807                             if(c == '\n' || c == L_EOF)
 808                                 yy_error_d("unterminated");
 809                         }
 810                         getc1();
 811                 } else {
 812                         /* <S>[A-Z_a-z0-9] */
 813
 814                         /* trick for fast drop id
 815                            if key with this first char undefined */
 816                         if(first_chars[c] == 0 || (mode & FALSE_MODES) != 0) {
 817                             /* skip <S>[A-Z_a-z0-9]+ */
 818                             do getc1(); while(isalnums[c]);
 819                         } else {
 820                             id_len = 0;
 821                             do {
 822                                 /* <S>[A-Z_a-z0-9]+ */
 823                                 put_id(c);
 824                                 getc1();
 825                             } while(isalnums[c]);
 826                             check_key(key_top, id, id_len);
 827                         }
 828                 }
 829                 continue;
 830         }
 831         /* begin preprocessor states */
 832         if(c == L_EOF)
 833             yy_error_d("unexpected EOF");
 834         if(c == REM) {
 835                 /* <#.*>/ */
 836                 getc0();
 837                 if(c == REM)
 838                         yy_error_d("detected // in preprocessor line");
 839                 if(c == '*') {
 840                         /* <#.*>[/][*] goto parse block comments */
 841                         break;
 842                 }
 843                 /* hmm, #.*[/] */
 844                 yy_error_d("strange preprocessor line");
 845         }
 846         if(state == POUND) {
 847             /* tricks */
 848             int diu = (int)first_chars_deiu[c];   /* preproc ptr */
 849
 850             state = S;
 851             if(diu != S) {
 852                 int p_num_str, p_num_max;
 853
 854                 getc1();
 855                 id_len = 0;
 856                 while(isalnums[c]) {
 857                     put_id(c);
 858                     getc1();
 859                 }
 860                 put_id(0);
 861                 p_num_str = diu & 0xf;
 862                 p_num_max = diu >> 4;
 863                 for(diu = p_num_str; diu <= p_num_max; diu++)
 864                     if(!strcmp(id, preproc[diu])) {
 865                         state = (diu + '0');
 866                         /* common */
 867                         id_len = 0;
 868                         break;
 869                 }
 870             } else {
 871                 while(isalnums[c]) getc1();
 872             }
 873         } else if(state == EF) {
 874                 /* #endif */
 875                 pop_mode();
 876                 state = S;
 877         } else if(state == I) {
 878                 if(c == STR && (mode & FALSE_MODES) == 0) {
 879                         /* <I>\" */
 880                         for(;;) {
 881                             getc1();
 882                             if(c == STR)
 883                                 break;
 884                             if(c == L_EOF)
 885                                 yy_error_d("unexpected EOF");
 886                             put_id(c);
 887                         }
 888                         put_id(0);
 889                         /* store "include.h" */
 890                         parse_inc(id, fname);
 891                         getc1();
 892                 }
 893                 /* else another (may be wrong) #include ... */
 894                 state = S;
 895         } else if(state == F) {
 896             arith_t t;
 897             int errcode;
 898
 899             while(c != '\n' && c != L_EOF) {
 900                 put_id(c);
 901                 getc1();
 902             }
 903             put_id(0);
 904             t = arith(id, &errcode);
 905             if (errcode < 0) {
 906                 if (errcode == -2)
 907                     yy_error_d("divide by zero");
 908                 else if (errcode == -4)
 909                     yy_error_d("undefined");
 910                 else if (errcode == -5)
 911                     yy_error_d("expression recursion loop detected");
 912                 else
 913                     yy_error_d("syntax error");
 914             }
 915             push_mode();
 916             mode = t != 0 ? IF1_MODE : IF0_MODE;
 917             state = S;
 918         } else if(state == IFD || state == IFND) {
 919             /* save KEY from #if(n)def KEY ... */
 920             const char *v;
 921
 922             push_mode();
 923             while(isalnums[c]) {
 924                 put_id(c);
 925                 getc1();
 926             }
 927             if(!id_len)
 928                 yy_error_d("expected identifier");
 929             v = lookup_key(id, id_len);
 930             mode = IF1_MODE;
 931             if(state == IFD && v == NULL)
 932                 mode = IF0_MODE;
 933             else if(state == IFND && v != NULL)
 934                     mode = IF0_MODE;
 935             state = S;
 936         } else if(state == EI) {
 937             /* #elif */
 938             if(mode == CONFIG_MODE || mode == ELSE0_MODE || mode == ELSE1_MODE)
 939                 yy_error_d("unexpected #elif");
 940             if(mode == IF0_MODE) {
 941                 pop_mode();
 942                 state = F;
 943             } else {
 944                 mode = ELIF1_MODE;
 945                 state = S;
 946             }
 947         } else if(state == E) {
 948             if(mode == CONFIG_MODE || mode == ELSE0_MODE || mode == ELSE1_MODE)
 949                 yy_error_d("unexpected #else");
 950             if(mode == IF0_MODE)
 951                 mode = ELSE0_MODE;
 952             else if(mode == IF1_MODE)
 953                 mode = ELSE1_MODE;
 954             state = S;
 955         } else if(state == D || state == U) {
 956             /* save KEY from #"define"|"undef" ... */
 957             while(isalnums[c]) {
 958                 put_id(c);
 959                 getc1();
 960             }
 961             if(!id_len)
 962                 yy_error_d("expected identifier");
 963             if(state == U) {
 964                 if((mode & FALSE_MODES) == 0)
 965                     parse_conf_opt(id, NULL, id_len);
 966                 state = S;
 967             } else {
 968                 /* D -> DK */
 969                 state = DK;
 970             }
 971         } else {
 972             /* state==<DK> #define KEY[ ] */
 973             size_t opt_len = id_len;
 974             char *val = id + opt_len;
 975             char *sp;
 976
 977             for(;;) {
 978                 if(c == L_EOF || c == '\n')
 979                     break;
 980                 put_id(c);
 981                 getc1();
 982             }
 983             sp = id + id_len;
 984             put_id(0);
 985             /* trim tail spaces */
 986             while(--sp >= val && (*sp == ' ' || *sp == '\t'
 987                                 || *sp == '\f' || *sp == '\v'))
 988                 *sp = '\0';
 989             if((mode & FALSE_MODES) == 0)
 990                 parse_conf_opt(id, val, opt_len);
 991             state = S;
 992         }
 993     }
 994
 995     /* <REM> */
 996     getc0();
 997     for(;;) {
 998           /* <REM>[^*]+ */
 999           while(c != '*') {
1000                 if(c == '\n') {
1001                     /* <REM>\n */
1002                     if(state != S)
1003                         yy_error_d("unexpected newline");
1004                     line++;
1005                 } else if(c == L_EOF)
1006                     yy_error_d("unexpected EOF");
1007                 getc0();
1008           }
1009           /* <REM>[*] */
1010           getc0();
1011           if(c == REM) {
1012                 /* <REM>[*][/] */
1013                 break;
1014           }
1015     }
1016   }
1017 too_long:
1018   yy_error_d("phrase too long");
1019 }
1020
1021 /* trick for fast find "define", "include", "undef" */
1022 static const char first_chars_diu[UCHAR_MAX] = {
1023         [(int)'d'] = (char)5,           /* strlen("define")  - 1; */
1024         [(int)'i'] = (char)6,           /* strlen("include") - 1; */
1025         [(int)'u'] = (char)4,           /* strlen("undef")   - 1; */
1026 };
1027
1028 #undef D
1029 #undef I
1030 #undef U
1031 #define D      '5'      /* #define preprocessor's directive */
1032 #define I      '6'      /* #include preprocessor's directive */
1033 #define U      '4'      /* #undef preprocessor's directive */
1034
1035 /* stupid C lexical analyser for sources */
1036 static void c_lex_src(const char *fname, long fsize)
1037 {
1038   int c;
1039   int state;
1040   int line;
1041   char *id = id_s;
1042   size_t id_len = 0;                /* stupid initialization */
1043   unsigned char *optr, *oend;
1044
1045   int fd;
1046   char *map;
1047   int mapsize;
1048
1049   if(fsize == 0) {
1050     fprintf(stderr, "Warning: %s is empty\n", fname);
1051     return;
1052   }
1053   fd = open(fname, O_RDONLY);
1054   if(fd < 0) {
1055         perror(fname);
1056         return;
1057   }
1058   mapsize = (fsize+pagesizem1) & ~pagesizem1;
1059   map = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, fd, 0);
1060   if ((long) map == -1)
1061         bb_error_d("%s: mmap: %m", fname);
1062
1063   optr = (unsigned char *)map;
1064   oend = optr + fsize;
1065
1066   line = 1;
1067   state = S;
1068
1069   for(;;) {
1070     getc1();
1071     for(;;) {
1072         /* [ \t]+ eat first space */
1073         while(c == ' ' || c == '\t')
1074             getc1();
1075
1076         if(state == S) {
1077                 while(first_chars[c] == ANY) {
1078                     /* <S>unparsed */
1079                     if(c == '\n')
1080                         line++;
1081                     getc1();
1082                 }
1083                 if(c == L_EOF) {
1084                         /* <S><<EOF>> */
1085                         munmap(map, mapsize);
1086                         close(fd);
1087                         return;
1088                 }
1089                 if(c == REM) {
1090                         /* <S>/ */
1091                         getc0();
1092                         if(c == REM) {
1093                                 /* <S>"//"[^\n]* */
1094                                 do getc0(); while(c != '\n' && c != L_EOF);
1095                         } else if(c == '*') {
1096                                 /* <S>[/][*] goto parse block comments */
1097                                 break;
1098                         }
1099                 } else if(c == POUND) {
1100                         /* <S># */
1101                         state = c;
1102                         getc1();
1103                 } else if(c == STR || c == CHR) {
1104                         /* <S>\"|\' */
1105                         int qc = c;
1106
1107                         for(;;) {
1108                             /* <STR,CHR>. */
1109                             getc1();
1110                             if(c == qc) {
1111                                 /* <STR>\" or <CHR>\' */
1112                                 break;
1113                             }
1114                             if(c == BS) {
1115                                 /* <STR,CHR>\\ but is not <STR,CHR>\\\n */
1116                                 getc0();
1117                             }
1118                             if(c == '\n' || c == L_EOF)
1119                                 yy_error_d("unterminated");
1120                         }
1121                         getc1();
1122                 } else {
1123                         /* <S>[A-Z_a-z0-9] */
1124
1125                         /* trick for fast drop id
1126                            if key with this first char undefined */
1127                         if(first_chars[c] == 0) {
1128                             /* skip <S>[A-Z_a-z0-9]+ */
1129                             do getc1(); while(isalnums[c]);
1130                         } else {
1131                             id_len = 0;
1132                             do {
1133                                 /* <S>[A-Z_a-z0-9]+ */
1134                                 put_id(c);
1135                                 getc1();
1136                             } while(isalnums[c]);
1137                             check_key(key_top, id, id_len);
1138                         }
1139                 }
1140                 continue;
1141         }
1142         /* begin preprocessor states */
1143         if(c == L_EOF)
1144             yy_error_d("unexpected EOF");
1145         if(c == REM) {
1146                 /* <#.*>/ */
1147                 getc0();
1148                 if(c == REM)
1149                         yy_error_d("detected // in preprocessor line");
1150                 if(c == '*') {
1151                         /* <#.*>[/][*] goto parse block comments */
1152                         break;
1153                 }
1154                 /* hmm, #.*[/] */
1155                 yy_error_d("strange preprocessor line");
1156         }
1157         if(state == POUND) {
1158             /* tricks */
1159             static const char * const p_preproc[] = {
1160                     /* 0 1   2  3     4        5        6 */
1161                     "", "", "", "", "ndef", "efine", "nclude"
1162             };
1163             size_t diu = first_chars_diu[c];   /* strlen and p_preproc ptr */
1164
1165             state = S;
1166             if(diu != S) {
1167                 getc1();
1168                 id_len = 0;
1169                 while(isalnums[c]) {
1170                     put_id(c);
1171                     getc1();
1172                 }
1173                 /* str begins with c, read == strlen key and compared */
1174                 if(diu == id_len && !memcmp(id, p_preproc[diu], diu)) {
1175                     state = diu + '0';
1176                     id_len = 0; /* common for save */
1177                 }
1178             } else {
1179                 while(isalnums[c]) getc1();
1180             }
1181         } else if(state == I) {
1182                 if(c == STR) {
1183                         /* <I>\" */
1184                         for(;;) {
1185                             getc1();
1186                             if(c == STR)
1187                                 break;
1188                             if(c == L_EOF)
1189                                 yy_error_d("unexpected EOF");
1190                             put_id(c);
1191                         }
1192                         put_id(0);
1193                         /* store "include.h" */
1194                         parse_inc(id, fname);
1195                         getc1();
1196                 }
1197                 /* else another (may be wrong) #include ... */
1198                 state = S;
1199         } else /* if(state == D || state == U) */ {
1200                 /* ignore depend with #define or #undef KEY */
1201                 while(isalnums[c]) getc1();
1202                 state = S;
1203         }
1204     }
1205
1206     /* <REM> */
1207     getc0();
1208     for(;;) {
1209           /* <REM>[^*]+ */
1210           while(c != '*') {
1211                 if(c == '\n') {
1212                     /* <REM>\n */
1213                     if(state != S)
1214                         yy_error_d("unexpected newline");
1215                     line++;
1216                 } else if(c == L_EOF)
1217                     yy_error_d("unexpected EOF");
1218                 getc0();
1219           }
1220           /* <REM>[*] */
1221           getc0();
1222           if(c == REM) {
1223                 /* <REM>[*][/] */
1224                 break;
1225           }
1226     }
1227   }
1228 too_long:
1229   yy_error_d("phrase too long");
1230 }
1231
1232
1233 /* bb_simplify_path special variant for absolute pathname */
1234 static size_t bb_qa_simplify_path(char *path)
1235 {
1236         char *s, *p;
1237
1238         p = s = path;
1239
1240         do {
1241             if (*p == '/') {
1242                 if (*s == '/') {    /* skip duplicate (or initial) slash */
1243                     continue;
1244                 } else if (*s == '.') {
1245                     if (s[1] == '/' || s[1] == 0) { /* remove extra '.' */
1246                         continue;
1247                     } else if ((s[1] == '.') && (s[2] == '/' || s[2] == 0)) {
1248                         ++s;
1249                         if (p > path) {
1250                             while (*--p != '/');    /* omit previous dir */
1251                         }
1252                         continue;
1253                     }
1254                 }
1255             }
1256             *++p = *s;
1257         } while (*++s);
1258
1259         if ((p == path) || (*p != '/')) {  /* not a trailing slash */
1260             ++p;                            /* so keep last character */
1261         }
1262         *p = 0;
1263
1264         return (p - path);
1265 }
1266
1267 static void parse_inc(const char *include, const char *fname)
1268 {
1269     bb_key_t *cur;
1270     const char *p_i;
1271     llist_t *lo;
1272     char *ap;
1273     size_t key_sz;
1274     struct stat st;
1275
1276     if(*include == '/') {
1277         lo = NULL;
1278         ap = bb_xstrdup(include);
1279     } else {
1280         int w;
1281         const char *p;
1282
1283         lo = Iop;
1284         p = strrchr(fname, '/');    /* fname has absolute pathname */
1285         w = (p-fname);
1286         /* find from current directory of source file */
1287         ap = bb_asprint("%.*s/%s", w, fname, include);
1288     }
1289
1290     for(;;) {
1291         key_sz = bb_qa_simplify_path(ap);
1292         cur = check_key(Ifound, ap, key_sz);
1293         if(cur) {
1294             cur->checked = cur->value;
1295             free(ap);
1296             return;
1297         }
1298         if(stat(ap, &st) == 0) {
1299             /* found */
1300             llist_t *cfl;
1301
1302             for(cfl = configs; cfl; cfl = cfl->link) {
1303                 struct stat *config = (struct stat *)cfl->data;
1304
1305                 if (st.st_dev == config->st_dev && st.st_ino == config->st_ino) {
1306                         /* skip depend with bb_configs.h */
1307                         return;
1308                 }
1309             }
1310             p_i = ap;
1311             break;
1312         } else if(lo == NULL) {
1313             p_i = NULL;
1314             break;
1315         }
1316
1317         /* find from "-I include" specified directories */
1318         free(ap);
1319         /* lo->data has absolute pathname */
1320         ap = bb_asprint("%s/%s", lo->data, include);
1321         lo = lo->link;
1322     }
1323
1324     cur = xmalloc(sizeof(bb_key_t));
1325     cur->keyname = ap;
1326     cur->key_sz = key_sz;
1327     cur->stored_path = ap;
1328     cur->value = cur->checked = p_i;
1329     if(p_i == NULL && noiwarning)
1330         fprintf(stderr, "%s: Warning: #include \"%s\" not found\n", fname, include);
1331     cur->next = Ifound;
1332     Ifound = cur;
1333 }
1334
1335 static size_t max_rec_sz;
1336
1337 static void parse_conf_opt(const char *opt, const char *val, size_t key_sz)
1338 {
1339         bb_key_t *cur;
1340         char *k;
1341         char *p;
1342         size_t val_sz = 0;
1343
1344         cur = check_key(key_top, opt, key_sz);
1345         if(cur != NULL) {
1346             /* already present */
1347             cur->checked = NULL;        /* store only */
1348             if(cur->value == NULL && val == NULL)
1349                 return;
1350             if(cur->value != NULL && val != NULL && !strcmp(cur->value, val))
1351                 return;
1352             k = cur->keyname;
1353             fprintf(stderr, "Warning: redefined %s\n", k);
1354         } else {
1355             size_t recordsz;
1356
1357             if(val && *val)
1358                 val_sz = strlen(val) + 1;
1359             recordsz = key_sz + val_sz + 1;
1360             if(max_rec_sz < recordsz)
1361                 max_rec_sz = recordsz;
1362             cur = xmalloc(sizeof(bb_key_t) + recordsz);
1363             k = cur->keyname = memcpy(cur + 1, opt, key_sz);
1364             cur->keyname[key_sz] = '\0';
1365             cur->key_sz = key_sz;
1366             cur->checked = NULL;
1367             cur->src_have_this_key = NULL;
1368             cur->next = key_top;
1369             key_top = cur;
1370         }
1371         /* save VAL */
1372         if(val) {
1373             if(*val == '\0') {
1374                 cur->value = "";
1375             } else {
1376                 cur->value = p = cur->keyname + key_sz + 1;
1377                 memcpy(p, val, val_sz);
1378             }
1379         } else {
1380             cur->value = NULL;
1381         }
1382         /* trick, save first char KEY for do fast identify id */
1383         first_chars[(int)*k] = *k;
1384
1385         cur->stored_path = k = bb_asprint("%s/%s.h", kp, k);
1386         /* key conversion [A-Z_] -> [a-z/] */
1387         for(p = k + kp_len + 1; *p; p++) {
1388             if(*p >= 'A' && *p <= 'Z')
1389                     *p = *p - 'A' + 'a';
1390             else if(*p == '_' && p[1] > '9')    /* do not change A_1 to A/1 */
1391                     *p = '/';
1392         }
1393 }
1394
1395 static void store_keys(void)
1396 {
1397     bb_key_t *cur;
1398     char *k;
1399     struct stat st;
1400     int cmp_ok;
1401     ssize_t rw_ret;
1402     size_t recordsz = max_rec_sz * 2 + 10 * 2 + 16;
1403     /* buffer for double "#define KEY VAL\n" */
1404     char *record_buf = xmalloc(recordsz);
1405
1406     for(cur = key_top; cur; cur = cur->next) {
1407         if(cur->src_have_this_key) {
1408             /* do generate record */
1409             k = cur->keyname;
1410             if(cur->value == NULL) {
1411                 recordsz = sprintf(record_buf, "#undef %s\n", k);
1412             } else {
1413                 const char *val = cur->value;
1414                 if(*val == '\0') {
1415                     recordsz = sprintf(record_buf, "#define %s\n", k);
1416                 } else {
1417                     if(val[0] != '(')
1418                         recordsz = sprintf(record_buf, "#define %s %s\n", k, val);
1419                     else
1420                         recordsz = sprintf(record_buf, "#define %s%s\n", k, val);
1421                 }
1422             }
1423             /* size_t -> ssize_t :( */
1424             rw_ret = (ssize_t)recordsz;
1425             /* check kp/key.h, compare after previous use */
1426             cmp_ok = 0;
1427             k = cur->stored_path;
1428             if(stat(k, &st)) {
1429                 char *p;
1430                 for(p = k + kp_len + 1; *p; p++) {
1431                     /* Auto-create directories. */
1432                     if (*p == '/') {
1433                         *p = '\0';
1434                         if (access(k, F_OK) != 0 && mkdir(k, 0755) != 0)
1435                             bb_error_d("mkdir(%s): %m", k);
1436                         *p = '/';
1437                     }
1438                 }
1439             } else {
1440                     /* found */
1441                     if(st.st_size == (off_t)recordsz) {
1442                         char *r_cmp;
1443                         int fd;
1444                         size_t padded = recordsz;
1445
1446                         /* 16-byte padding for read(2) and memcmp(3) */
1447                         padded = (padded+15) & ~15;
1448                         r_cmp = record_buf + padded;
1449                         fd = open(k, O_RDONLY);
1450                         if(fd < 0 || read(fd, r_cmp, recordsz) < rw_ret)
1451                             bb_error_d("%s: %m", k);
1452                         close(fd);
1453                         cmp_ok = memcmp(record_buf, r_cmp, recordsz) == 0;
1454                     }
1455             }
1456             if(!cmp_ok) {
1457                 int fd = open(k, O_WRONLY|O_CREAT|O_TRUNC, 0644);
1458                 if(fd < 0 || write(fd, record_buf, recordsz) < rw_ret)
1459                     bb_error_d("%s: %m", k);
1460                 close(fd);
1461             }
1462         }
1463     }
1464 }
1465
1466 static int show_dep(int first, bb_key_t *k, const char *name, const char *f)
1467 {
1468     bb_key_t *cur;
1469
1470     for(cur = k; cur; cur = cur->next) {
1471         if(cur->checked) {
1472             if(first >= 0) {
1473                 if(first) {
1474                     if(f == NULL)
1475                         printf("\n%s:", name);
1476                     else
1477                         printf("\n%s/%s:", pwd, name);
1478                     first = 0;
1479                 } else {
1480                     printf(" \\\n  ");
1481                 }
1482                 printf(" %s", cur->checked);
1483             }
1484             cur->src_have_this_key = cur->checked;
1485             cur->checked = NULL;
1486         }
1487     }
1488     return first;
1489 }
1490
1491 static char *
1492 parse_chd(const char *fe, const char *p, size_t dirlen)
1493 {
1494     struct stat st;
1495     char *fp;
1496     size_t df_sz;
1497     static char dir_and_entry[4096];
1498     size_t fe_sz = strlen(fe) + 1;
1499
1500     df_sz = dirlen + fe_sz + 1;         /* dir/file\0 */
1501     if(df_sz > sizeof(dir_and_entry))
1502         bb_error_d("%s: file name too long", fe);
1503     fp = dir_and_entry;
1504     /* sprintf(fp, "%s/%s", p, fe); */
1505     memcpy(fp, p, dirlen);
1506     fp[dirlen] = '/';
1507     memcpy(fp + dirlen + 1, fe, fe_sz);
1508
1509     if(stat(fp, &st)) {
1510         fprintf(stderr, "Warning: stat(%s): %m\n", fp);
1511         return NULL;
1512     }
1513     if(S_ISREG(st.st_mode)) {
1514         llist_t *cfl;
1515         char *e = fp + df_sz - 3;
1516
1517         if(*e++ != '.' || (*e != 'c' && *e != 'h')) {
1518             /* direntry is regular file, but is not *.[ch] */
1519             return NULL;
1520         }
1521         for(cfl = configs; cfl; cfl = cfl->link) {
1522             struct stat *config = (struct stat *)cfl->data;
1523
1524             if (st.st_dev == config->st_dev && st.st_ino == config->st_ino) {
1525                 /* skip already parsed bb_configs.h */
1526                 return NULL;
1527             }
1528         }
1529         /* direntry is *.[ch] regular file and is not configs */
1530         c_lex_src(fp, st.st_size);
1531         if(!dontgenerate_dep) {
1532             int first;
1533             if(*e == 'c') {
1534                 /* *.c -> *.o */
1535                 *e = 'o';
1536                 /* /src_dir/path/file.o to path/file.o */
1537                 fp += replace;
1538                 if(*fp == '/')
1539                     fp++;
1540             } else {
1541                 e = NULL;
1542             }
1543             first = show_dep(1, Ifound, fp, e);
1544             first = show_dep(first, key_top, fp, e);
1545             if(first == 0)
1546                 putchar('\n');
1547         } else {
1548             show_dep(-1, key_top, NULL, NULL);
1549         }
1550         return NULL;
1551     } else if(S_ISDIR(st.st_mode)) {
1552         if (st.st_dev == st_kp.st_dev && st.st_ino == st_kp.st_ino)
1553             return NULL;    /* drop scan kp/ directory */
1554         /* direntry is directory. buff is returned */
1555         return bb_xstrdup(fp);
1556     }
1557     /* hmm, direntry is device! */
1558     return NULL;
1559 }
1560
1561 /* from libbb but inlined for speed considerations */
1562 static inline llist_t *llist_add_to(llist_t *old_head, char *new_item)
1563 {
1564         llist_t *new_head;
1565
1566         new_head = xmalloc(sizeof(llist_t));
1567         new_head->data = new_item;
1568         new_head->link = old_head;
1569
1570         return(new_head);
1571 }
1572
1573 static void scan_dir_find_ch_files(const char *p)
1574 {
1575     llist_t *dirs;
1576     llist_t *d_add;
1577     llist_t *d;
1578     struct dirent *de;
1579     DIR *dir;
1580     size_t dirlen;
1581
1582     dirs = llist_add_to(NULL, bb_simplify_path(p));
1583     replace = strlen(dirs->data);
1584     /* emulate recursion */
1585     while(dirs) {
1586         d_add = NULL;
1587         while(dirs) {
1588             dir = opendir(dirs->data);
1589             if (dir == NULL)
1590                 fprintf(stderr, "Warning: opendir(%s): %m\n", dirs->data);
1591             dirlen = strlen(dirs->data);
1592             while ((de = readdir(dir)) != NULL) {
1593                 char *found_dir;
1594
1595                 if (de->d_name[0] == '.')
1596                         continue;
1597                 found_dir = parse_chd(de->d_name, dirs->data, dirlen);
1598                 if(found_dir)
1599                     d_add = llist_add_to(d_add, found_dir);
1600             }
1601             closedir(dir);
1602             free(dirs->data);
1603             d = dirs;
1604             dirs = dirs->link;
1605             free(d);
1606         }
1607         dirs = d_add;
1608     }
1609 }
1610
1611 static void show_usage(void) ATTRIBUTE ((noreturn));
1612 static void show_usage(void)
1613 {
1614         bb_error_d("%s\n%s\n", bb_mkdep_terse_options, bb_mkdep_full_options);
1615 }
1616
1617 int main(int argc, char **argv)
1618 {
1619         char *s;
1620         int i;
1621         llist_t *fl;
1622
1623         {
1624             /* for bb_simplify_path, this program has no chdir() */
1625             /* libbb-like my xgetcwd() */
1626             unsigned path_max = 512;
1627
1628             s = xmalloc (path_max);
1629             while (getcwd (s, path_max) == NULL) {
1630                 if(errno != ERANGE)
1631                     bb_error_d("getcwd: %m");
1632                 free(s);
1633                 s = xmalloc(path_max *= 2);
1634             }
1635             pwd = s;
1636         }
1637
1638         while ((i = getopt(argc, argv, "I:c:dk:w")) > 0) {
1639                 switch(i) {
1640                     case 'I':
1641                             s = bb_simplify_path(optarg);
1642                             Iop = llist_add_to(Iop, s);
1643                             break;
1644                     case 'c':
1645                             s = bb_simplify_path(optarg);
1646                             configs = llist_add_to(configs, s);
1647                             break;
1648                     case 'd':
1649                             dontgenerate_dep = 1;
1650                             break;
1651                     case 'k':
1652                             if(kp)
1653                                 bb_error_d("Hmm, why multiple -k?");
1654                             kp = bb_simplify_path(optarg);
1655                             break;
1656                     case 'w':
1657                             noiwarning = 1;
1658                             break;
1659                     default:
1660                             show_usage();
1661                 }
1662         }
1663         /* default kp */
1664         if(kp == NULL)
1665             kp = bb_simplify_path(INCLUDE_CONFIG_PATH);
1666         /* globals initialize */
1667         kp_len = strlen(kp);
1668         if(stat(kp, &st_kp))
1669             bb_error_d("stat(%s): %m", kp);
1670         if(!S_ISDIR(st_kp.st_mode))
1671             bb_error_d("%s is not directory", kp);
1672         /* defaults */
1673         if(Iop == NULL)
1674             Iop = llist_add_to(Iop, bb_simplify_path(LOCAL_INCLUDE_PATH));
1675         if(configs == NULL) {
1676             s = bb_simplify_path(INCLUDE_CONFIG_KEYS_PATH);
1677             configs = llist_add_to(configs, s);
1678         }
1679         /* for c_lex */
1680         pagesizem1 = getpagesize() - 1;
1681         for(i = 0; i < UCHAR_MAX; i++) {
1682             if(ISALNUM(i))
1683                 isalnums[i] = i;
1684             /* set unparsed chars to speed up the parser */
1685             else if(i != CHR && i != STR && i != POUND && i != REM)
1686                 first_chars[i] = ANY;
1687         }
1688         first_chars[i] = '-';   /* L_EOF */
1689
1690         /* parse configs */
1691         for(fl = configs; fl; fl = fl->link) {
1692             struct stat st;
1693
1694             if(stat(fl->data, &st))
1695                 bb_error_d("stat(%s): %m", fl->data);
1696             c_lex_config(fl->data, st.st_size);
1697             free(fl->data);
1698             /* trick for fast comparing found files with configs */
1699             fl->data = xmalloc(sizeof(struct stat));
1700             memcpy(fl->data, &st, sizeof(struct stat));
1701         }
1702
1703         /* main loop */
1704         argv += optind;
1705         if(*argv) {
1706             while(*argv)
1707                 scan_dir_find_ch_files(*argv++);
1708         } else {
1709                 scan_dir_find_ch_files(".");
1710         }
1711         store_keys();
1712         return 0;
1713 }
1714
1715 /* partial and simplified libbb routine */
1716 static void bb_error_d(const char *s, ...)
1717 {
1718         va_list p;
1719
1720         va_start(p, s);
1721         vfprintf(stderr, s, p);
1722         va_end(p);
1723         putc('\n', stderr);
1724         exit(1);
1725 }
1726
1727 static char *bb_asprint(const char *format, ...)
1728 {
1729         va_list p;
1730         int r;
1731         char *out;
1732
1733 #ifdef __USE_GNU
1734         va_start(p, format);
1735         r = vasprintf(&out, format, p);
1736         va_end(p);
1737 #else
1738         out = xmalloc(BUFSIZ);
1739         va_start(p, format);
1740         r = vsprintf(out, format, p);
1741         va_end(p);
1742 #endif
1743
1744         if (r < 0)
1745                 bb_error_d("bb_asprint: %m");
1746         return out;
1747 }
1748
1749 /* partial libbb routine as is */
1750
1751 static char *bb_simplify_path(const char *path)
1752 {
1753         char *s, *start, *p;
1754
1755         if (path[0] == '/')
1756                 start = bb_xstrdup(path);
1757         else {
1758                 /* is not libbb, but this program has no chdir() */
1759                 start = bb_asprint("%s/%s", pwd, path);
1760         }
1761         p = s = start;
1762
1763         do {
1764             if (*p == '/') {
1765                 if (*s == '/') {    /* skip duplicate (or initial) slash */
1766                     continue;
1767                 } else if (*s == '.') {
1768                     if (s[1] == '/' || s[1] == 0) { /* remove extra '.' */
1769                         continue;
1770                     } else if ((s[1] == '.') && (s[2] == '/' || s[2] == 0)) {
1771                         ++s;
1772                         if (p > start) {
1773                             while (*--p != '/');    /* omit previous dir */
1774                         }
1775                         continue;
1776                     }
1777                 }
1778             }
1779             *++p = *s;
1780         } while (*++s);
1781
1782         if ((p == start) || (*p != '/')) {  /* not a trailing slash */
1783             ++p;                            /* so keep last character */
1784         }
1785         *p = 0;
1786
1787         return start;
1788 }