scripts/bb_mkdep.c

   1 /*
   2  * Another fast dependencies generator for Makefiles, Version 2.0
   3  *
   4  * Copyright (C) 2005 by Vladimir Oleynik <dzo@simtreas.ru>
   5  *
   6  * This program does:
   7  * 1) find #define KEY VALUE or #undef KEY from include/config.h
   8  * 2) save include/config/key*.h if changed after previous usage
   9  * 3) recursive scan from "./" *.[ch] files, but skips scan of include/config/
  10  * 4) find #include "*.h" and KEYs using, if not as #define and #undef
  11  * 5) generate dependencies to stdout
  12  *    path/file.o: include/config/key*.h found_include_*.h
  13  *    path/inc.h: include/config/key*.h found_included_include_*.h
  14  * This programm does not generate dependencies for #include <...>
  15  */
  16
  17 #define LOCAL_INCLUDE_PATH          "include"
  18 #define INCLUDE_CONFIG_PATH         LOCAL_INCLUDE_PATH"/config"
  19 #define INCLUDE_CONFIG_KEYS_PATH    LOCAL_INCLUDE_PATH"/config.h"
  20
  21 #define bb_mkdep_full_options \
  22 "\nOptions:" \
  23 "\n\t-I local_include_path  include paths, default: \"" LOCAL_INCLUDE_PATH "\"" \
  24 "\n\t-d                     don't generate depend" \
  25 "\n\t-w                     show warning if include files not found" \
  26 "\n\t-k include/config      default: \"" INCLUDE_CONFIG_PATH "\"" \
  27 "\n\t-c include/config.h    configs, default: \"" INCLUDE_CONFIG_KEYS_PATH "\"" \
  28 "\n\tdirs_to_scan           default \".\""
  29
  30 #define bb_mkdep_terse_options "Usage: [-I local_include_paths] [-dw] " \
  31                    "[-k path_for_stored_keys] [dirs]"
  32
  33
  34
  35 #define _GNU_SOURCE
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38 #include <sys/mman.h>
  39 #include <getopt.h>
  40 #include <dirent.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <stdarg.h>
  45 #include <unistd.h>
  46 #include <errno.h>
  47 #include <fcntl.h>
  48
  49
  50 typedef struct BB_KEYS {
  51         char *keyname;
  52         const char *value;
  53         char *stored_path;
  54         int  checked;
  55         struct BB_KEYS *next;
  56 } bb_key_t;
  57
  58 static bb_key_t *check_key(bb_key_t *k, const char *nk);
  59 static bb_key_t *make_new_key(bb_key_t *k, const char *nk);
  60
  61 /* partial and simplified libbb routine */
  62 static void bb_error_d(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2)));
  63 static char * bb_asprint(const char *format, ...) __attribute__ ((format (printf, 1, 2)));
  64
  65 /* stolen from libbb as is */
  66 typedef struct llist_s {
  67         char *data;
  68         struct llist_s *link;
  69 } llist_t;
  70 static void *xrealloc(void *p, size_t size);
  71 static void *xmalloc(size_t size);
  72 static char *bb_xstrdup(const char *s);
  73 static char *bb_simplify_path(const char *path);
  74 /* error messages */
  75 static const char msg_enomem[] = "memory exhausted";
  76
  77 /* for lexical analyser */
  78 static bb_key_t *key_top;
  79 static llist_t *configs;
  80
  81 static int mode;
  82 #define CONFIG_MODE  0
  83 #define SOURCES_MODE 1
  84
  85 static void parse_inc(const char *include, const char *fname);
  86 static void parse_conf_opt(char *opt, const char *val, size_t rsz);
  87
  88 /* for speed tricks */
  89 static char first_chars[257];  /* + L_EOF */
  90 /* trick for fast find "define", "include", "undef" */
  91 static char first_chars_diu[256];
  92
  93 static int pagesizem1;
  94 static size_t mema_id = 128;   /* first allocated for id */
  95 static char *id_s;
  96
  97
  98
  99 #define yy_error_d(s) bb_error_d("%s:%d hmm, %s", fname, line, s)
 100
 101 /* state */
 102 #define S      0        /* start state */
 103 #define STR    '"'      /* string */
 104 #define CHR    '\''     /* char */
 105 #define REM    '/'      /* block comment */
 106 #define BS     '\\'     /* back slash */
 107 #define POUND  '#'      /* # */
 108 #define I      'i'      /* #include preprocessor's directive */
 109 #define D      'd'      /* #define preprocessor's directive */
 110 #define U      'u'      /* #undef preprocessor's directive */
 111 #define LI     'I'      /* #include "... */
 112 #define DK     'K'      /* #define KEY... (config mode) */
 113 #define DV     'V'      /* #define KEY "VALUE or #define KEY 'VALUE */
 114 #define NLC    'n'      /* \ and \n */
 115 #define ANY    '*'      /* any unparsed chars */
 116
 117 #define L_EOF  256
 118 /* [A-Z_a-z] */
 119 #define ID(c) ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
 120 /* [A-Z_a-z0-9] */
 121 #define ISALNUM(c)  (ID(c) || (c >= '0' && c <= '9'))
 122
 123 #define getc1()     do { c = (optr >= oend) ? L_EOF : *optr++; } while(0)
 124 #define ungetc1()   optr--
 125
 126 #define put_id(c)   do {    if(id_len == local_mema_id)                 \
 127                                 id = xrealloc(id, local_mema_id += 16); \
 128                             id[id_len++] = c; } while(0)
 129
 130
 131
 132 /* stupid C lexical analyser */
 133 static void c_lex(const char *fname, long fsize)
 134 {
 135   int c = L_EOF;                     /* stupid initialize */
 136   int prev_state = L_EOF;
 137   int called;
 138   int state;
 139   int line;
 140   char *id = id_s;
 141   size_t local_mema_id = mema_id;
 142   size_t id_len = 0;                /* stupid initialize */
 143   char *val = NULL;
 144   unsigned char *optr, *oend;
 145   unsigned char *start = NULL;      /* stupid initialize */
 146
 147   int fd;
 148   char *map;
 149   int mapsize;
 150
 151   if(fsize == 0) {
 152     fprintf(stderr, "Warning: %s is empty\n", fname);
 153     return;
 154   }
 155   fd = open(fname, O_RDONLY);
 156   if(fd < 0) {
 157         perror(fname);
 158         return;
 159   }
 160   mapsize = (fsize+pagesizem1) & ~pagesizem1;
 161   map = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, fd, 0);
 162   if ((long) map == -1)
 163         bb_error_d("%s: mmap: %m", fname);
 164
 165   optr = (unsigned char *)map;
 166   oend = optr + fsize;
 167
 168   line = 1;
 169   called = state = S;
 170
 171   for(;;) {
 172         if(state == LI || state == DV) {
 173             /* store "include.h" or config mode #define KEY "|'..."|'  */
 174             put_id(0);
 175             if(state == LI) {
 176                 parse_inc(id, fname);
 177             } else {
 178                 /* #define KEY "[VAL]" */
 179                 parse_conf_opt(id, val, (optr - start));
 180             }
 181             state = S;
 182         }
 183         if(prev_state != state) {
 184             prev_state = state;
 185             getc1();
 186         }
 187
 188         /* [ \t]+ eat first space */
 189         while(c == ' ' || c == '\t')
 190             getc1();
 191
 192         if(c == BS) {
 193                 getc1();
 194                 if(c == '\n') {
 195                         /* \\\n eat continued */
 196                         line++;
 197                         prev_state = NLC;
 198                         continue;
 199                 }
 200                 ungetc1();
 201                 c = BS;
 202         }
 203
 204         if(state == S) {
 205                 while(first_chars[c] == ANY) {
 206                     /* <S>unparsed */
 207                     if(c == '\n')
 208                         line++;
 209                     getc1();
 210                 }
 211                 if(c == L_EOF) {
 212                         /* <S><<EOF>> */
 213                         id_s = id;
 214                         mema_id = local_mema_id;
 215                         munmap(map, mapsize);
 216                         close(fd);
 217                         return;
 218                 }
 219                 if(c == REM) {
 220                         /* <S>/ */
 221                         getc1();    /* eat <S>/ */
 222                         if(c == REM) {
 223                                 /* <S>"//"[^\n]* */
 224                                 do getc1(); while(c != '\n' && c != L_EOF);
 225                         } else if(c == '*') {
 226                                 /* <S>[/][*] */
 227                                 called = S;
 228                                 state = REM;
 229                         }
 230                 } else if(c == POUND) {
 231                         /* <S># */
 232                         start = optr - 1;
 233                         state = c;
 234                 } else if(c == STR || c == CHR) {
 235                         /* <S>\"|\' */
 236                         val = NULL;
 237                         called = S;
 238                         state = c;
 239                 } else if(c != BS) {
 240                         /* <S>[A-Z_a-z0-9] */
 241
 242                         /* trick for fast drop id
 243                            if key with this first char undefined */
 244                         if(first_chars[c] == 0) {
 245                             /* skip <S>[A-Z_a-z0-9]+ */
 246                             do getc1(); while(ISALNUM(c));
 247                         } else {
 248                             id_len = 0;
 249                             do {
 250                                 /* <S>[A-Z_a-z0-9]+ */
 251                                 put_id(c);
 252                                 getc1();
 253                             } while(ISALNUM(c));
 254                             put_id(0);
 255                             check_key(key_top, id);
 256                         }
 257                 } else {
 258                     /* <S>\\ */
 259                     prev_state = c;
 260                 }
 261                 continue;
 262         }
 263         if(state == REM) {
 264           for(;;) {
 265                 /* <REM>[^*]+ */
 266                 while(c != '*') {
 267                         if(c == '\n') {
 268                                 /* <REM>\n */
 269                                 if(called != S)
 270                                     yy_error_d("unexpected newline");
 271                                 line++;
 272                         } else if(c == L_EOF)
 273                                 yy_error_d("unexpected EOF");
 274                         getc1();
 275                 }
 276                 /* <REM>[*] */
 277                 getc1();
 278                 if(c == REM) {
 279                         /* <REM>[*][/] */
 280                         state = called;
 281                         break;
 282                 }
 283           }
 284           continue;
 285         }
 286         if(state == STR || state == CHR) {
 287             for(;;) {
 288                 /* <STR,CHR>\n|<<EOF>> */
 289                 if(c == '\n' || c == L_EOF)
 290                         yy_error_d("unterminated");
 291                 if(c == BS) {
 292                         /* <STR,CHR>\\ */
 293                         getc1();
 294                         if(c != BS && c != '\n' && c != state) {
 295                             /* another usage \ in str or char */
 296                             if(c == L_EOF)
 297                                 yy_error_d("unexpected EOF");
 298                             if(val)
 299                                 put_id(c);
 300                             continue;
 301                         }
 302                         /* <STR,CHR>\\[\\\n] or <STR>\\\" or <CHR>\\\' */
 303                         /* eat 2 char */
 304                         if(c == '\n')
 305                             line++;
 306                         else if(val)
 307                             put_id(c);
 308                 } else if(c == state) {
 309                         /* <STR>\" or <CHR>\' */
 310                         if(called == DV)
 311                             put_id(c);  /* #define KEY "VALUE"<- */
 312                         state = called;
 313                         break;
 314                 } else if(val)
 315                         put_id(c);
 316                 /* <STR,CHR>. */
 317                 getc1();
 318             }
 319             continue;
 320         }
 321
 322         /* begin preprocessor states */
 323         if(c == L_EOF)
 324             yy_error_d("unexpected EOF");
 325         if(c == REM) {
 326                 /* <#.*>/ */
 327                 getc1();
 328                 if(c == REM)
 329                         yy_error_d("detected // in preprocessor line");
 330                 if(c == '*') {
 331                         /* <#.*>[/][*] */
 332                         called = state;
 333                         state = REM;
 334                         continue;
 335                 }
 336                 /* hmm, #.*[/] */
 337                 yy_error_d("strange preprocessor line");
 338         }
 339         if(state == POUND) {
 340             const unsigned char *p = optr - 1;
 341             /* tricks */
 342             static const char * const preproc[] = {
 343                     /* 0-4 */
 344                     "", "", "", "", "",
 345                     /* 5 */   /* 6 */   /* 7 */
 346                     "undef", "define", "include",
 347             };
 348             size_t readed = 0;
 349             size_t diu = first_chars_diu[c];   /* strlen and preproc ptr */
 350
 351             while(ISALNUM(c)) {
 352                 readed++;
 353                 getc1();
 354             }
 355             /* have str begined with c, readed == strlen key and compared */
 356             if(diu != S && diu == readed && !memcmp(p, preproc[diu], diu)) {
 357                 state = *p;
 358                 id_len = 0; /* common for save */
 359             } else {
 360                 state = S;
 361             }
 362             ungetc1();
 363             continue;
 364         }
 365         if(state == I) {
 366                 if(c == STR) {
 367                         /* <I>\" */
 368                         val = id;
 369                         called = LI;
 370                         state = STR;
 371                 } else {
 372                     /* another (may be wrong) #include ... */
 373                     ungetc1();
 374                     state = S;
 375                 }
 376                 continue;
 377         }
 378         if(state == D || state == U) {
 379             if(mode == SOURCES_MODE) {
 380                 /* ignore depend with #define or #undef KEY */
 381                 while(ISALNUM(c))
 382                     getc1();
 383                 state = S;
 384             } else {
 385                 /* save KEY from #"define"|"undef" ... */
 386                 while(ISALNUM(c)) {
 387                     put_id(c);
 388                     getc1();
 389                 }
 390                 if(!id_len)
 391                     yy_error_d("expected identifier");
 392                 put_id(0);
 393                 if(state == U) {
 394                     parse_conf_opt(id, NULL, (optr - start));
 395                     state = S;
 396                 } else {
 397                     /* D -> DK */
 398                     state = DK;
 399                 }
 400             }
 401             ungetc1();
 402             continue;
 403         }
 404         if(state == DK) {
 405             /* #define KEY[ ] (config mode) */
 406             val = id + id_len;
 407             if(c == STR || c == CHR) {
 408                 /* define KEY "... or define KEY '... */
 409                 put_id(c);
 410                 called = DV;
 411                 state = c;
 412                 continue;
 413             }
 414             while(ISALNUM(c)) {
 415                 /* VALUE */
 416                 put_id(c);
 417                 getc1();
 418             }
 419             ungetc1();
 420             state = DV;
 421             continue;
 422         }
 423     }
 424 }
 425
 426
 427 static void show_usage(void) __attribute__ ((noreturn));
 428 static void show_usage(void)
 429 {
 430         bb_error_d("%s\n%s\n", bb_mkdep_terse_options, bb_mkdep_full_options);
 431 }
 432
 433 static const char *kp;
 434 static size_t kp_len;
 435 static llist_t *Iop;
 436 static bb_key_t *Ifound;
 437 static int noiwarning;
 438
 439 static bb_key_t *check_key(bb_key_t *k, const char *nk)
 440 {
 441     bb_key_t *cur;
 442
 443     for(cur = k; cur; cur = cur->next) {
 444         if(strcmp(cur->keyname, nk) == 0) {
 445             cur->checked = 1;
 446             return cur;
 447         }
 448     }
 449     return NULL;
 450 }
 451
 452 static bb_key_t *make_new_key(bb_key_t *k, const char *nk)
 453 {
 454         bb_key_t *cur;
 455         size_t nk_size;
 456
 457         nk_size = strlen(nk) + 1;
 458         cur = xmalloc(sizeof(bb_key_t) + nk_size);
 459         cur->keyname = memcpy(cur + 1, nk, nk_size);
 460         cur->checked = 0;
 461         cur->next = k;
 462         return cur;
 463 }
 464
 465 static inline char *store_include_fullpath(char *p_i, bb_key_t *li)
 466 {
 467     char *ok;
 468
 469     if(access(p_i, F_OK) == 0) {
 470         ok = li->stored_path = bb_simplify_path(p_i);
 471         li->checked = 1;
 472     } else {
 473         ok = NULL;
 474     }
 475     free(p_i);
 476     return ok;
 477 }
 478
 479 static void parse_inc(const char *include, const char *fname)
 480 {
 481         bb_key_t *li;
 482         char *p_i;
 483         llist_t *lo;
 484
 485         li = check_key(Ifound, include);
 486         if(li)
 487             return;
 488         Ifound = li = make_new_key(Ifound, include);
 489
 490         if(include[0] != '/') {
 491             /* relative */
 492             int w;
 493             const char *p;
 494
 495             p_i = strrchr(fname, '/');
 496             if(p_i == NULL) {
 497                 p = ".";
 498                 w = 1;
 499             } else {
 500                 w = (p_i-fname);
 501                 p = fname;
 502             }
 503             p_i = bb_asprint("%.*s/%s", w, p, include);
 504             if(store_include_fullpath(p_i, li))
 505                 return;
 506             for(lo = Iop; lo; lo = lo->link) {
 507                 p_i = bb_asprint("%s/%s", lo->data, include);
 508                 if(store_include_fullpath(p_i, li))
 509                     return;
 510             }
 511         } else {
 512             /* absolute include pathname */
 513             if(access(include, F_OK) == 0) {
 514                 li->stored_path = bb_xstrdup(include);
 515                 li->checked = 1;
 516                 return;
 517             }
 518         }
 519         li->stored_path = NULL;
 520         if(noiwarning)
 521             fprintf(stderr, "%s: Warning: #include \"%s\" not found in specified paths\n", fname, include);
 522 }
 523
 524 static void parse_conf_opt(char *opt, const char *val, size_t recordsz)
 525 {
 526         bb_key_t *cur;
 527         char *s, *p;
 528         struct stat st;
 529         int fd;
 530         int cmp_ok = 0;
 531         static char *record_buf;
 532         static char *r_cmp;
 533         static size_t r_sz;
 534         ssize_t rw_ret;
 535
 536         cur = check_key(key_top, opt);
 537         if(cur != NULL) {
 538             /* present already */
 539             cur->checked = 0;   /* store only */
 540             if(cur->value == NULL && val == NULL)
 541                 return;
 542             if(cur->value != NULL && val != NULL && strcmp(cur->value, val) == 0)
 543                 return;
 544             fprintf(stderr, "Warning: redefined %s\n", opt);
 545         }
 546         /* new or redefined key, check old key if present after previous usage */
 547         key_top = cur = make_new_key(key_top, opt);
 548
 549         recordsz += 2;  /* \n\0 */
 550         if(recordsz > r_sz) {
 551             record_buf = xrealloc(record_buf, r_sz=recordsz);
 552             r_cmp = xrealloc(r_cmp, recordsz);
 553         }
 554         s = record_buf;
 555         /* may be short count " " */
 556         if(val) {
 557             if(*val == '\0') {
 558                 cur->value = "";
 559                 recordsz = sprintf(s, "#define %s\n", opt);
 560             } else {
 561                 cur->value = bb_xstrdup(val);
 562                 recordsz = sprintf(s, "#define %s %s\n", opt, val);
 563             }
 564         } else {
 565             cur->value = NULL;
 566             recordsz = sprintf(s, "#undef %s\n", opt);
 567         }
 568         /* size_t -> ssize_t :( */
 569         rw_ret = (ssize_t)recordsz;
 570         /* trick, save first char KEY for do fast identify id */
 571         first_chars[(int)*opt] = *opt;
 572
 573         /* key converting [A-Z_] -> [a-z/] */
 574         for(p = opt; *p; p++) {
 575             if(*p >= 'A' && *p <= 'Z')
 576                     *p = *p - 'A' + 'a';
 577             else if(*p == '_')
 578                     *p = '/';
 579         }
 580         p = bb_asprint("%s/%s.h", kp, opt);
 581         cur->stored_path = opt = p;
 582         if(stat(opt, &st)) {
 583             p += kp_len;
 584             while(*++p) {
 585                 /* Auto-create directories. */
 586                 if (*p == '/') {
 587                     *p = '\0';
 588                     if (access(opt, F_OK) != 0 && mkdir(opt, 0755) != 0)
 589                         bb_error_d("mkdir(%s): %m", opt);
 590                     *p = '/';
 591                 }
 592             }
 593         } else {
 594                 /* found */
 595                 if(st.st_size == (off_t)recordsz) {
 596                     fd = open(opt, O_RDONLY);
 597                     if(fd < 0 || read(fd, r_cmp, recordsz) < rw_ret)
 598                         bb_error_d("%s: %m", opt);
 599                     close(fd);
 600                     cmp_ok = memcmp(s, r_cmp, recordsz) == 0;
 601                 }
 602         }
 603         if(!cmp_ok) {
 604             fd = open(opt, O_WRONLY|O_CREAT|O_TRUNC, 0644);
 605             if(fd < 0 || write(fd, s, recordsz) < rw_ret)
 606                 bb_error_d("%s: %m", opt);
 607             close(fd);
 608         }
 609 }
 610
 611 static int show_dep(int first, bb_key_t *k, const char *name)
 612 {
 613     bb_key_t *cur;
 614
 615     for(cur = k; cur; cur = cur->next) {
 616         if(cur->checked && cur->stored_path) {
 617             if(first) {
 618                 printf("\n%s:", name);
 619                 first = 0;
 620             } else {
 621                 printf(" \\\n  ");
 622             }
 623             printf(" %s", cur->stored_path);
 624         }
 625         cur->checked = 0;
 626     }
 627     return first;
 628 }
 629
 630 static struct stat st_kp;
 631 static int dontgenerate_dep;
 632
 633 static char *
 634 parse_chd(const char *fe, const char *p, size_t dirlen)
 635 {
 636     struct stat st;
 637     char *fp;
 638     size_t df_sz;
 639     static char *dir_and_entry;
 640     static size_t dir_and_entry_sz;
 641
 642     if (*fe == '.')
 643         return NULL;
 644
 645     df_sz = dirlen + strlen(fe) + 2;     /* dir/file\0 */
 646     if(df_sz > dir_and_entry_sz)
 647         dir_and_entry = xrealloc(dir_and_entry, dir_and_entry_sz = df_sz);
 648     fp = dir_and_entry;
 649     sprintf(fp, "%s/%s", p, fe);
 650
 651     if(stat(fp, &st)) {
 652         fprintf(stderr, "Warning: stat(%s): %m", fp);
 653         return NULL;
 654     }
 655     if(S_ISREG(st.st_mode)) {
 656         llist_t *cfl;
 657         char *e = fp + df_sz - 3;
 658
 659         if(*e++ != '.' || (*e != 'c' && *e != 'h')) {
 660             /* direntry is regular file, but is not *.[ch] */
 661             return NULL;
 662         }
 663         for(cfl = configs; cfl; cfl = cfl->link) {
 664             struct stat *config = (struct stat *)cfl->data;
 665
 666             if (st.st_dev == config->st_dev && st.st_ino == config->st_ino) {
 667                 /* skip already parsed configs.h */
 668                 return NULL;
 669             }
 670         }
 671         /* direntry is *.[ch] regular file and is not configs */
 672         if(!dontgenerate_dep) {
 673             int first;
 674
 675             c_lex(fp, st.st_size);
 676             fp = bb_simplify_path(fp);
 677             if(*e == 'c') {
 678                 /* *.c -> *.o */
 679                 e = strrchr(fp, '.') + 1;
 680                 *e = 'o';
 681             }
 682             first = show_dep(1, Ifound, fp);
 683             first = show_dep(first, key_top, fp);
 684             if(first == 0)
 685                 putchar('\n');
 686             free(fp);
 687         }
 688         return NULL;
 689     } else if(S_ISDIR(st.st_mode)) {
 690         if (st.st_dev == st_kp.st_dev && st.st_ino == st_kp.st_ino)
 691             return NULL;    /* drop scan kp/ directory */
 692         /* direntry is directory. buff is returned, begin of zero allocate */
 693         dir_and_entry = NULL;
 694         dir_and_entry_sz = 0;
 695         return fp;
 696     }
 697     /* hmm, direntry is device! */
 698     return NULL;
 699 }
 700
 701 /* from libbb but inline for fast */
 702 static inline llist_t *llist_add_to(llist_t *old_head, char *new_item)
 703 {
 704         llist_t *new_head;
 705
 706         new_head = xmalloc(sizeof(llist_t));
 707         new_head->data = new_item;
 708         new_head->link = old_head;
 709
 710         return(new_head);
 711 }
 712
 713 static void scan_dir_find_ch_files(char *p)
 714 {
 715     llist_t *dirs;
 716     llist_t *d_add;
 717     llist_t *d;
 718     struct dirent *de;
 719     DIR *dir;
 720     size_t dirlen;
 721
 722     dirs = llist_add_to(NULL, p);
 723     /* emulate recursive */
 724     while(dirs) {
 725         d_add = NULL;
 726         while(dirs) {
 727             dir = opendir(dirs->data);
 728             if (dir == NULL)
 729                 fprintf(stderr, "Warning: opendir(%s): %m", dirs->data);
 730             dirlen = strlen(dirs->data);
 731             while ((de = readdir(dir)) != NULL) {
 732                 char *found_dir = parse_chd(de->d_name, dirs->data, dirlen);
 733
 734                 if(found_dir)
 735                     d_add = llist_add_to(d_add, found_dir);
 736             }
 737             closedir(dir);
 738             if(dirs->data != p)
 739                 free(dirs->data);
 740             d = dirs;
 741             dirs = dirs->link;
 742             free(d);
 743         }
 744         dirs = d_add;
 745     }
 746 }
 747
 748 static char *pwd;
 749
 750 int main(int argc, char **argv)
 751 {
 752         char *s;
 753         int i;
 754         llist_t *fl;
 755
 756         {
 757             /* for bb_simplify_path */
 758             /* libbb xgetcwd(), this program have not chdir() */
 759             unsigned path_max = 512;
 760
 761             s = xmalloc (path_max);
 762 #define PATH_INCR 32
 763             while (getcwd (s, path_max) == NULL) {
 764                 if(errno != ERANGE)
 765                     bb_error_d("getcwd: %m");
 766                 s = xrealloc (s, path_max += PATH_INCR);
 767                 }
 768             pwd = s;
 769         }
 770
 771         while ((i = getopt(argc, argv, "I:c:dk:w")) > 0) {
 772                 switch(i) {
 773                     case 'I':
 774                             Iop = llist_add_to(Iop, optarg);
 775                             break;
 776                     case 'c':
 777                             s = bb_simplify_path(optarg);
 778                             configs = llist_add_to(configs, s);
 779                             break;
 780                     case 'd':
 781                             dontgenerate_dep = 1;
 782                             break;
 783                     case 'k':
 784                             if(kp)
 785                                 bb_error_d("Hmm, why multiple -k?");
 786                             kp = bb_simplify_path(optarg);
 787                             break;
 788                     case 'w':
 789                             noiwarning = 1;
 790                             break;
 791                     default:
 792                             show_usage();
 793                 }
 794         }
 795         /* default kp */
 796         if(kp == NULL)
 797             kp = bb_simplify_path(INCLUDE_CONFIG_PATH);
 798         /* globals initialize */
 799         kp_len = strlen(kp);
 800         if(stat(kp, &st_kp))
 801             bb_error_d("stat(%s): %m", kp);
 802         if(!S_ISDIR(st_kp.st_mode))
 803             bb_error_d("%s is not directory", kp);
 804         /* defaults */
 805         if(Iop == NULL)
 806             Iop = llist_add_to(Iop, LOCAL_INCLUDE_PATH);
 807         if(configs == NULL) {
 808             s = bb_simplify_path(INCLUDE_CONFIG_KEYS_PATH);
 809             configs = llist_add_to(configs, s);
 810         }
 811         /* for c_lex */
 812         pagesizem1 = getpagesize() - 1;
 813         id_s = xmalloc(mema_id);
 814         for(i = 0; i < 256; i++) {
 815             /* set unparsed chars for speed up of parser */
 816             if(!ISALNUM(i) && i != CHR && i != STR &&
 817                               i != POUND && i != REM && i != BS)
 818                 first_chars[i] = ANY;
 819         }
 820         first_chars[i] = '-';   /* L_EOF */
 821         /* trick for fast find "define", "include", "undef" */
 822         first_chars_diu[(int)'d'] = (char)6;    /* strlen("define");  */
 823         first_chars_diu[(int)'i'] = (char)7;    /* strlen("include"); */
 824         first_chars_diu[(int)'u'] = (char)5;    /* strlen("undef");   */
 825
 826         /* parse configs */
 827         for(fl = configs; fl; fl = fl->link) {
 828             struct stat st;
 829
 830             if(stat(fl->data, &st))
 831                 bb_error_d("stat(%s): %m", fl->data);
 832             c_lex(fl->data, st.st_size);
 833             /* trick for fast comparing found files with configs */
 834             fl->data = xrealloc(fl->data, sizeof(struct stat));
 835             memcpy(fl->data, &st, sizeof(struct stat));
 836         }
 837
 838         /* main loop */
 839         mode = SOURCES_MODE;
 840         argv += optind;
 841         if(*argv) {
 842             while(*argv)
 843                 scan_dir_find_ch_files(*argv++);
 844         } else {
 845                 scan_dir_find_ch_files(".");
 846         }
 847         return 0;
 848 }
 849
 850 /* partial and simplified libbb routine */
 851 static void bb_error_d(const char *s, ...)
 852 {
 853         va_list p;
 854
 855         va_start(p, s);
 856         vfprintf(stderr, s, p);
 857         va_end(p);
 858         putc('\n', stderr);
 859         exit(1);
 860 }
 861
 862 static char *bb_asprint(const char *format, ...)
 863 {
 864         va_list p;
 865         int r;
 866         char *out;
 867
 868         va_start(p, format);
 869         r = vasprintf(&out, format, p);
 870         va_end(p);
 871
 872         if (r < 0)
 873                 bb_error_d("bb_asprint: %m");
 874         return out;
 875 }
 876
 877 /* partial libbb routine as is */
 878 static void *xmalloc(size_t size)
 879 {
 880         void *p = malloc(size);
 881
 882         if(p == NULL)
 883                 bb_error_d(msg_enomem);
 884         return p;
 885 }
 886
 887 static void *xrealloc(void *p, size_t size) {
 888         p = realloc(p, size);
 889         if(p == NULL)
 890                 bb_error_d(msg_enomem);
 891         return p;
 892 }
 893
 894 static char *bb_xstrdup(const char *s)
 895 {
 896         char *r = strdup(s);
 897
 898         if(r == NULL)
 899             bb_error_d(msg_enomem);
 900         return r;
 901 }
 902
 903 static char *bb_simplify_path(const char *path)
 904 {
 905         char *s, *start, *p;
 906
 907         if (path[0] == '/')
 908                 start = bb_xstrdup(path);
 909         else {
 910                 /* is not libbb, but this program have not chdir() */
 911                 start = bb_asprint("%s/%s", pwd, path);
 912         }
 913         p = s = start;
 914
 915         do {
 916             if (*p == '/') {
 917                 if (*s == '/') {    /* skip duplicate (or initial) slash */
 918                     continue;
 919                 } else if (*s == '.') {
 920                     if (s[1] == '/' || s[1] == 0) { /* remove extra '.' */
 921                         continue;
 922                     } else if ((s[1] == '.') && (s[2] == '/' || s[2] == 0)) {
 923                         ++s;
 924                         if (p > start) {
 925                             while (*--p != '/');    /* omit previous dir */
 926                         }
 927                         continue;
 928                     }
 929                 }
 930             }
 931             *++p = *s;
 932         } while (*++s);
 933
 934         if ((p == start) || (*p != '/')) {  /* not a trailing slash */
 935             ++p;                            /* so keep last character */
 936         }
 937         *p = 0;
 938
 939         return start;
 940 }