new my scripts/mm_mkdep, dependences work now

3 files changed, 855 insertions, 854 deletions

diff --git a/scripts/bb_mkdep.c b/scripts/bb_mkdep.c
new file mode 100644
index 000000000..408397332
--- /dev/null
+++ b/scripts/bb_mkdep.c
@@ -0,0 +1,855 @@
+/*
+ * Another dependences for Makefile mashine generator
+ *
+ * Copyright (C) 2005 by Vladimir Oleynik <dzo@simtreas.ru>
+ *
+ * This programm do
+ * 1) find #define KEY VALUE or #undef KEY from include/config.h
+ * 2) save include/config/key*.h if changed after previous usage
+ * 3) recursive scan from "./" *.[ch] files, but skip scan include/config/...
+ * 4) find #include "*.h" and KEYs using, if not as #define and #undef
+ * 5) generate depend to stdout
+ *    path/file.o: include/config/key*.h found_include_*.h
+ *    path/inc.h: include/config/key*.h found_included_include_*.h
+ * This programm do not generate dependences for #include <...>
+ *
+ * Options:
+ * -I local_include_path  (include`s paths, default: LOCAL_INCLUDE_PATH)
+ * -d                     (don`t generate depend)
+ * -w                     (show warning if include files not found)
+ * -k include/config      (default: INCLUDE_CONFIG_PATH)
+ * -c include/config.h    (configs, default: INCLUDE_CONFIG_KEYS_PATH)
+*/
+
+#define LOCAL_INCLUDE_PATH          "include"
+#define INCLUDE_CONFIG_PATH         LOCAL_INCLUDE_PATH"/config"
+#define INCLUDE_CONFIG_KEYS_PATH    LOCAL_INCLUDE_PATH"/config.h"
+
+#define _GNU_SOURCE
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <getopt.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+
+typedef struct BB_KEYS {
+        char *keyname;
+        const char *value;
+        char *stored_path;
+        int  checked;
+        struct BB_KEYS *next;
+} bb_key_t;
+
+
+/* partial and simplify libbb routine */
+
+void bb_error_d(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2)));
+char * bb_asprint(const char *format, ...) __attribute__ ((format (printf, 1, 2)));
+
+/* stolen from libbb as is */
+typedef struct llist_s {
+        char *data;
+        struct llist_s *link;
+} llist_t;
+llist_t *llist_add_to(llist_t *old_head, char *new_item);
+void *xrealloc(void *p, size_t size);
+void *xmalloc(size_t size);
+char *bb_xstrdup(const char *s);
+char *bb_simplify_path(const char *path);
+
+/* for lexical analyzier */
+static bb_key_t *key_top;
+
+static void parse_inc(const char *include, const char *fname);
+static void parse_conf_opt(char *opt, const char *val, size_t rsz);
+
+#define CHECK_ONLY  0
+#define MAKE_NEW    1
+static bb_key_t *find_already(bb_key_t *k, const char *nk, int flg_save_new);
+
+#define yy_error_d(s) bb_error_d("%s:%d hmm, %s", fname, line, s)
+
+/* state */
+#define S      0        /* start state */
+#define STR    '"'      /* string */
+#define CHR    '\''     /* char */
+#define REM    '*'      /* block comment */
+#define POUND  '#'      /* # */
+#define I      'i'      /* #include preprocessor`s directive */
+#define D      'd'      /* #define preprocessor`s directive */
+#define U      'u'      /* #undef preprocessor`s directive */
+#define LI     'I'      /* #include "... */
+#define DK     'K'      /* #define KEY... (config mode) */
+#define DV     'V'      /* #define KEY "... or #define KEY '... */
+#define NLC    'n'      /* \+\n */
+#define ANY    '?'      /* skip unparsed . */
+
+/* [A-Z_a-z] */
+#define ID(c) ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
+/* [A-Z_a-z0-9] */
+#define ISALNUM(c)  (ID(c) || (c >= '0' && c <= '9'))
+
+#define getc1()     do { c = (optr >= oend) ? EOF : *optr++; } while(0)
+#define ungetc1()   optr--
+
+#define put_id(c)   do {    if(id_len == mema_id)                 \
+                                id = xrealloc(id, mema_id += 16); \
+                            id[id_len++] = c; } while(0)
+
+/* stupid C lexical analizator */
+static void c_lex(const char *fname, int flg_config_include)
+{
+  int c = EOF;                      /* stupid initialize */
+  int prev_state = EOF;
+  int called;
+  int state;
+  int line;
+  static size_t mema_id;
+  char *id = xmalloc(mema_id=128);  /* fist allocate */
+  size_t id_len = 0;                /* stupid initialize */
+  char *val = NULL;
+  unsigned char *optr, *oend;
+  unsigned char *start = NULL;      /* stupid initialize */
+
+  int fd;
+  char *map;
+  int mapsize;
+  {
+    /* stolen from mkdep by Linus Torvalds */
+    int pagesizem1 = getpagesize() - 1;
+    struct stat st;
+
+    fd = open(fname, O_RDONLY);
+    if(fd < 0) {
+        perror(fname);
+        return;
+    }
+    fstat(fd, &st);
+    if (st.st_size == 0)
+        bb_error_d("%s is empty", fname);
+    mapsize = st.st_size;
+    mapsize = (mapsize+pagesizem1) & ~pagesizem1;
+    map = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, fd, 0);
+    if ((long) map == -1)
+        bb_error_d("%s: mmap: %m", fname);
+
+    /* hereinafter is my */
+    optr = (unsigned char *)map;
+    oend = optr + st.st_size;
+  }
+
+  line = 1;
+  called = state = S;
+
+  for(;;) {
+        if(state == LI || state == DV) {
+            /* store "include.h" or config mode #define KEY "|'..."|'  */
+            put_id(0);
+            if(state == LI) {
+                parse_inc(id, fname);
+            } else {
+                /*
+                if(val[0] == '\0')
+                    yy_error_d("expected value");
+                */
+                parse_conf_opt(id, val, (optr - start));
+            }
+            state = S;
+        }
+        if(prev_state != state) {
+            prev_state = state;
+            getc1();
+        }
+
+        /* [ \t]+ eat first space */
+        while(c == ' ' || c == '\t')
+            getc1();
+
+        if(c == '\\') {
+                getc1();
+                if(c == '\n') {
+                        /* \\\n eat continued */
+                        line++;
+                        prev_state = NLC;
+                        continue;
+                }
+                ungetc1();
+                c = '\\';
+        }
+
+        if(state == S) {
+                while(c <= ' ' && c != EOF) {
+                    /* <S>[\000- ]+ */
+                    if(c == '\n')
+                        line++;
+                    getc1();
+                }
+                if(c == EOF) {
+                        /* <S><<EOF>> */
+                        munmap(map, mapsize);
+                        close(fd);
+                        return;
+                }
+                if(c == '/') {
+                        /* <S>/ */
+                        getc1();
+                        if(c == '/') {
+                                /* <S>"//"[^\n]* */
+                                do getc1(); while(c != '\n' && c != EOF);
+                        } else if(c == '*') {
+                                /* <S>[/][*] */
+                                called = S;
+                                state = REM;
+                        }
+                        /* eat <S>/ */
+                } else if(c == '#') {
+                        /* <S>\"|\'|# */
+                        start = optr - 1;
+                        state = c;
+                } else if(c == STR || c == CHR) {
+                        /* <S>\"|\'|# */
+                        val = NULL;
+                        called = S;
+                        state = c;
+                } else if(ISALNUM(c)) {
+                        /* <S>[A-Z_a-z0-9] */
+                        id_len = 0;
+                        do {
+                                /* <S>[A-Z_a-z0-9]+ */
+                                put_id(c);
+                                getc1();
+                        } while(ISALNUM(c));
+                        put_id(0);
+                        find_already(key_top, id, CHECK_ONLY);
+                } else {
+                    /* <S>. */
+                    prev_state = ANY;
+                }
+                continue;
+        }
+        if(state == REM) {
+          for(;;) {
+                /* <REM>[^*]+ */
+                while(c != '*') {
+                        if(c == '\n') {
+                                /* <REM>\n */
+                                if(called != S)
+                                    yy_error_d("unexpected newline");
+                                line++;
+                        } else if(c == EOF)
+                                yy_error_d("unexpected EOF");
+                        getc1();
+                }
+                /* <REM>[*] */
+                getc1();
+                if(c == '/') {
+                        /* <REM>[*][/] */
+                        state = called;
+                        break;
+                }
+          }
+          continue;
+        }
+        if(state == STR || state == CHR) {
+            for(;;) {
+                /* <STR,CHR>\n|<<EOF>> */
+                if(c == '\n' || c == EOF)
+                        yy_error_d("unterminating");
+                if(c == '\\') {
+                        /* <STR,CHR>\\ */
+                        getc1();
+                        if(c != '\\' && c != '\n' && c != state) {
+                            /* another usage \ in str or char */
+                            if(c == EOF)
+                                yy_error_d("unexpected EOF");
+                            if(val)
+                                put_id(c);
+                            continue;
+                        }
+                        /* <STR,CHR>\\[\\\n] or <STR>\\\" or <CHR>\\\' */
+                        /* eat 2 char */
+                        if(c == '\n')
+                            line++;
+                        else if(val)
+                            put_id(c);
+                } else if(c == state) {
+                        /* <STR>\" or <CHR>\' */
+                        if(called == DV)
+                            put_id(c);
+                        state = called;
+                        break;
+                } else if(val)
+                        put_id(c);
+                /* <STR,CHR>. */
+                getc1();
+            }
+            continue;
+        }
+
+        /* begin preprocessor states */
+        if(c == EOF)
+            yy_error_d("unexpected EOF");
+        if(c == '/') {
+                /* <#.*>/ */
+                getc1();
+                if(c == '/')
+                        yy_error_d("detect // in preprocessor line");
+                if(c == '*') {
+                        /* <#.*>[/][*] */
+                        called = state;
+                        state = REM;
+                        continue;
+                }
+                /* hmm, #.*[/] */
+                yy_error_d("strange preprocessor line");
+        }
+        if(state == '#') {
+                static const char * const preproc[] = {
+                    "define", "undef", "include", ""
+                };
+                const char * const *str_type;
+
+                id_len = 0;
+                while(ISALNUM(c)) {
+                    put_id(c);
+                    getc1();
+                }
+                put_id(0);
+                for(str_type = preproc; (state = **str_type); str_type++) {
+                    if(*id == state && strcmp(id, *str_type) == 0)
+                        break;
+                }
+                /* to S if another #directive */
+                ungetc1();
+                id_len = 0; /* common for save */
+                continue;
+        }
+        if(state == I) {
+                if(c == STR) {
+                        /* <I>\" */
+                        val = id;
+                        state = STR;
+                        called = LI;
+                        continue;
+                }
+                /* another (may be wrong) #include ... */
+                ungetc1();
+                state = S;
+                continue;
+        }
+        if(state == D || state == U) {
+            while(ISALNUM(c)) {
+                if(flg_config_include) {
+                    /* save KEY from #"define"|"undef" ... */
+                    put_id(c);
+                }
+                getc1();
+            }
+            if(!flg_config_include) {
+                state = S;
+            } else {
+                if(!id_len)
+                    yy_error_d("expected identificator");
+                put_id(0);
+                if(state == U) {
+                    parse_conf_opt(id, NULL, (optr - start));
+                    state = S;
+                } else {
+                    /* D -> DK */
+                    state = DK;
+                }
+            }
+            ungetc1();
+            continue;
+        }
+        if(state == DK) {
+            /* #define (config mode) */
+            val = id + id_len;
+            if(c == STR || c == CHR) {
+                /* define KEY "... or define KEY '... */
+                put_id(c);
+                called = DV;
+                state = c;
+                continue;
+            }
+            while(ISALNUM(c)) {
+                put_id(c);
+                getc1();
+            }
+            ungetc1();
+            state = DV;
+            continue;
+        }
+    }
+}
+
+
+static void show_usage(void) __attribute__ ((noreturn));
+static void show_usage(void)
+{
+        bb_error_d("Usage: [-I local_include_path] [-dw] "
+                        "[-k path_for_store_keys] [-s skip_file]");
+}
+
+static const char *kp;
+static llist_t *Iop;
+static bb_key_t *Ifound;
+static int noiwarning;
+static llist_t *configs;
+
+static bb_key_t *find_already(bb_key_t *k, const char *nk, int flg_save_new)
+{
+        bb_key_t *cur;
+
+        for(cur = k; cur; cur = cur->next) {
+            if(strcmp(cur->keyname, nk) == 0) {
+                cur->checked = 1;
+                return NULL;
+            }
+        }
+        if(flg_save_new == CHECK_ONLY)
+            return NULL;
+        cur = xmalloc(sizeof(bb_key_t));
+        cur->keyname = bb_xstrdup(nk);
+        cur->checked = 1;
+        cur->next = k;
+        return cur;
+}
+
+static int store_include_fullpath(char *p_i, bb_key_t *li)
+{
+    struct stat st;
+    int ok = 0;
+
+    if(stat(p_i, &st) == 0) {
+        li->stored_path = bb_simplify_path(p_i);
+        ok = 1;
+    }
+    free(p_i);
+    return ok;
+}
+
+static void parse_inc(const char *include, const char *fname)
+{
+        bb_key_t *li;
+        char *p_i;
+        llist_t *lo;
+
+        if((li = find_already(Ifound, include, MAKE_NEW)) == NULL)
+            return;
+        Ifound = li;
+        if(include[0] != '/') {
+            /* relative */
+            int w;
+            const char *p;
+
+            p_i = strrchr(fname, '/');
+            if(p_i == NULL) {
+                p = ".";
+                w = 1;
+            } else {
+                w = (p_i-fname);
+                p = fname;
+            }
+            p_i = bb_asprint("%.*s/%s", w, p, include);
+            if(store_include_fullpath(p_i, li))
+                return;
+        }
+        for(lo = Iop; lo; lo = lo->link) {
+            p_i = bb_asprint("%s/%s", lo->data, include);
+            if(store_include_fullpath(p_i, li))
+                return;
+        }
+        li->stored_path = NULL;
+        if(noiwarning)
+            fprintf(stderr, "%s: Warning: #include \"%s\" not found in specified paths\n", fname, include);
+}
+
+static void parse_conf_opt(char *opt, const char *val, size_t recordsz)
+{
+        bb_key_t *cur = find_already(key_top, opt, MAKE_NEW);
+
+        if(cur != NULL) {
+            /* new key, check old key if present after previous usage */
+            char *s, *p;
+            struct stat st;
+            int fd;
+            int cmp_ok = 0;
+            static char *record_buf;
+            static char *r_cmp;
+            static size_t r_sz;
+
+            recordsz += 2;  /* \n\0 */
+            if(recordsz > r_sz) {
+                record_buf = xrealloc(record_buf, r_sz=recordsz);
+                r_cmp = xrealloc(r_cmp, recordsz);
+            }
+            s = record_buf;
+            if(val)
+                sprintf(s, "#define %s%s%s\n", opt, (*val ? " " : ""), val);
+            else
+                sprintf(s, "#undef %s\n", opt);
+            /* may be short count " " */
+            recordsz = strlen(s);
+            /* key converting [A-Z] -> [a-z] */
+            for(p = opt; *p; p++) {
+                if(*p >= 'A' && *p <= 'Z')
+                        *p = *p - 'A' + 'a';
+                if(*p == '_')
+                    *p = '/';
+            }
+            p = bb_asprint("%s/%s.h", kp, opt);
+            cur->stored_path = opt = p;
+            while(*++p) {
+                /* Auto-create directories. */
+                if (*p == '/') {
+                    *p = '\0';
+                    if (stat(opt, &st) != 0 && mkdir(opt, 0755) != 0)
+                        bb_error_d("mkdir(%s): %m", opt);
+                    *p = '/';
+                }
+            }
+            if(stat(opt, &st) == 0) {
+                    /* found */
+                    if(st.st_size == recordsz) {
+                        fd = open(opt, O_RDONLY);
+                        if(fd < 0 || read(fd, r_cmp, recordsz) != recordsz)
+                            bb_error_d("%s: %m", opt);
+                        close(fd);
+                        cmp_ok = memcmp(s, r_cmp, recordsz) == 0;
+                    }
+            }
+            if(!cmp_ok) {
+                fd = open(opt, O_WRONLY|O_CREAT|O_TRUNC, 0644);
+                if(fd < 0 || write(fd, s, recordsz) != recordsz)
+                    bb_error_d("%s: %m", opt);
+                close(fd);
+            }
+            /* store only */
+            cur->checked = 0;
+            if(val) {
+                if(*val == '\0') {
+                    cur->value = "";
+                } else {
+                    cur->value = bb_xstrdup(val);
+                }
+            } else {
+                cur->value = NULL;
+            }
+            key_top = cur;
+        } else {
+            /* present already */
+            for(cur = key_top; cur; cur = cur->next) {
+                if(strcmp(cur->keyname, opt) == 0) {
+                    cur->checked = 0;
+                    if(cur->value == NULL && val == NULL)
+                        return;
+                    if((cur->value == NULL && val != NULL) ||
+                            (cur->value != NULL && val == NULL) ||
+                            strcmp(cur->value, val))
+                        fprintf(stderr, "Warning: redefined %s\n", opt);
+                    return;
+                }
+            }
+        }
+}
+
+static int show_dep(int first, bb_key_t *k, const char *a)
+{
+    bb_key_t *cur;
+
+    for(cur = k; cur; cur = cur->next) {
+        if(cur->checked && cur->stored_path) {
+            if(first) {
+                const char *ext;
+
+                if(*a == '.' && a[1] == '/')
+                    a += 2;
+                ext = strrchr(a, '.');
+                if(ext && ext[1] == 'c' && ext[2] == '\0') {
+                    /* *.c -> *.o */
+                    printf("\n%.*s.o:", (ext - a), a);
+                } else {
+                    printf("\n%s:", a);
+                }
+                first = 0;
+            } else {
+                printf(" \\\n  ");
+            }
+            printf(" %s", cur->stored_path);
+        }
+        cur->checked = 0;
+    }
+    return first;
+}
+
+static llist_t *files;
+
+static llist_t *filter_chd(const char *fe, const char *p, llist_t *pdirs)
+{
+    const char *e;
+    struct stat st;
+    char *fp;
+    char *afp;
+    llist_t *cfl;
+
+    if (*fe == '.')
+        return NULL;
+    fp = bb_asprint("%s/%s", p, fe);
+    if(stat(fp, &st)) {
+        fprintf(stderr, "Warning: stat(%s): %m", fp);
+        free(fp);
+        return NULL;
+    }
+    afp = bb_simplify_path(fp);
+    if(S_ISDIR(st.st_mode)) {
+        if(strcmp(kp, afp) == 0) {
+            /* is autogenerated to kp/key* by previous usage */
+            free(afp);
+            free(fp);
+            /* drop scan kp/ directory */
+            return NULL;
+        }
+        free(afp);
+        return llist_add_to(pdirs, fp);
+    }
+    if(!S_ISREG(st.st_mode)) {
+        /* hmm, is device! */
+        free(afp);
+        free(fp);
+        return NULL;
+    }
+    e = strrchr(fe, '.');
+    if(e == NULL || !((e[1]=='c' || e[1]=='h') && e[2]=='\0')) {
+        /* direntry is not directory or *.[ch] */
+        free(afp);
+        free(fp);
+        return NULL;
+    }
+    for(cfl = configs; cfl; cfl = cfl->link) {
+        if(cfl->data && strcmp(cfl->data, afp) == 0) {
+            /* parse configs.h */
+            free(afp);
+            c_lex(fp, 1);
+            free(fp);
+            free(cfl->data);
+            cfl->data = NULL;
+            return NULL;
+        }
+    }
+    free(fp);
+    /* direntry is *.[ch] regular file */
+    files = llist_add_to(files, afp);
+    return NULL;
+}
+
+static void scan_dir_find_ch_files(char *p)
+{
+    llist_t *dirs;
+    llist_t *d_add;
+    llist_t *d;
+    struct dirent *de;
+    DIR *dir;
+
+    dirs = llist_add_to(NULL, p);
+    /* emulate recursive */
+    while(dirs) {
+        d_add = NULL;
+        while(dirs) {
+            dir = opendir(dirs->data);
+            if (dir == NULL)
+                fprintf(stderr, "Warning: opendir(%s): %m", dirs->data);
+            while ((de = readdir(dir)) != NULL) {
+                d = filter_chd(de->d_name, dirs->data, d_add);
+                if(d)
+                    d_add = d;
+            }
+            closedir(dir);
+            if(dirs->data != p)
+                free(dirs->data);
+            d = dirs;
+            dirs = dirs->link;
+            free(d);
+        }
+        dirs = d_add;
+    }
+}
+
+int main(int argc, char **argv)
+{
+        int generate_dep = 1;
+        char *s;
+        int i;
+        llist_t *fl;
+
+        while ((i = getopt(argc, argv, "I:c:dk:w")) > 0) {
+                switch(i) {
+                    case 'I':
+                            Iop = llist_add_to(Iop, optarg);
+                            break;
+                    case 'c':
+                            s = bb_simplify_path(optarg);
+                            configs = llist_add_to(configs, s);
+                            break;
+                    case 'd':
+                            generate_dep = 0;
+                            break;
+                    case 'k':
+                            if(kp)
+                                bb_error_d("Hmm, why multiple -k?");
+                            kp = bb_simplify_path(optarg);
+                            break;
+                    case 'w':
+                            noiwarning = 1;
+                            break;
+                    default:
+                            show_usage();
+                }
+        }
+        if(argc > optind)
+            show_usage();
+
+        /* defaults */
+        if(kp == NULL)
+            kp = bb_simplify_path(INCLUDE_CONFIG_PATH);
+        if(Iop == NULL)
+            Iop = llist_add_to(Iop, LOCAL_INCLUDE_PATH);
+        if(configs == NULL) {
+            s = bb_simplify_path(INCLUDE_CONFIG_KEYS_PATH);
+            configs = llist_add_to(configs, s);
+        }
+        scan_dir_find_ch_files(".");
+
+        for(fl = files; fl; fl = fl->link) {
+                c_lex(fl->data, 0);
+                if(generate_dep) {
+                        i = show_dep(1, Ifound, fl->data);
+                        i = show_dep(i, key_top, fl->data);
+                        if(i == 0)
+                                putchar('\n');
+                }
+        }
+        return 0;
+}
+
+void bb_error_d(const char *s, ...)
+{
+        va_list p;
+
+        va_start(p, s);
+        vfprintf(stderr, s, p);
+        va_end(p);
+        putc('\n', stderr);
+        exit(1);
+}
+
+
+void *xmalloc(size_t size)
+{
+        void *p = malloc(size);
+
+        if(p == NULL)
+                bb_error_d("memory exhausted");
+        return p;
+}
+
+void *xrealloc(void *p, size_t size) {
+        p = realloc(p, size);
+        if(p == NULL)
+                bb_error_d("memory exhausted");
+        return p;
+}
+
+char *bb_asprint(const char *format, ...)
+{
+        va_list p;
+        int r;
+        char *out;
+
+        va_start(p, format);
+        r = vasprintf(&out, format, p);
+        va_end(p);
+
+        if (r < 0)
+                bb_error_d("bb_asprint: %m");
+        return out;
+}
+
+llist_t *llist_add_to(llist_t *old_head, char *new_item)
+{
+        llist_t *new_head;
+
+        new_head = xmalloc(sizeof(llist_t));
+        new_head->data = new_item;
+        new_head->link = old_head;
+
+        return(new_head);
+}
+
+char *bb_xstrdup(const char *s)
+{
+    char *r = strdup(s);
+    if(r == NULL)
+        bb_error_d("memory exhausted");
+    return r;
+}
+
+char *bb_simplify_path(const char *path)
+{
+        char *s, *start, *p;
+
+        if (path[0] == '/')
+              start = bb_xstrdup(path);
+        else {
+              static char *pwd;
+
+              if(pwd == NULL) {
+                    /* is not libbb, but this program have not chdir() */
+                    unsigned path_max = 512;
+                    char *cwd = xmalloc (path_max);
+#define PATH_INCR 32
+                    while (getcwd (cwd, path_max) == NULL) {
+                        if(errno != ERANGE)
+                            bb_error_d("getcwd: %m");
+                        path_max += PATH_INCR;
+                        cwd = xrealloc (cwd, path_max);
+                    }
+                    pwd = cwd;
+            }
+            start = bb_asprint("%s/%s", pwd, path);
+        }
+        p = s = start;
+
+        do {
+                if (*p == '/') {
+                        if (*s == '/') {        /* skip duplicate (or initial) slash */
+                                continue;
+                        } else if (*s == '.') {
+                                if (s[1] == '/' || s[1] == 0) { /* remove extra '.' */
+                                        continue;
+                                } else if ((s[1] == '.') && (s[2] == '/' || s[2] == 0)) {
+                                        ++s;
+                                        if (p > start) {
+                                                while (*--p != '/');    /* omit previous dir */
+                                        }
+                                        continue;
+                                }
+                        }
+                }
+                *++p = *s;
+        } while (*++s);
+
+        if ((p == start) || (*p != '/')) {      /* not a trailing slash */
+                ++p;                            /* so keep last character */
+        }
+        *p = 0;
+
+        return start;
+}
diff --git a/scripts/mkdep.c b/scripts/mkdep.c
deleted file mode 100644
index ae3cc74e0..000000000
--- a/scripts/mkdep.c
+++ /dev/null
@@ -1,628 +0,0 @@
-/*
- * Originally by Linus Torvalds.
- * Smart CONFIG_* processing by Werner Almesberger, Michael Chastain.
- *
- * Usage: mkdep cflags -- file ...
- *
- * Read source files and output makefile dependency lines for them.
- * I make simple dependency lines for #include <*.h> and #include "*.h".
- * I also find instances of CONFIG_FOO and generate dependencies
- *    like include/config/foo.h.
- *
- * 1 August 1999, Michael Elizabeth Chastain, <mec@shout.net>
- * - Keith Owens reported a bug in smart config processing.  There used
- *   to be an optimization for "#define CONFIG_FOO ... #ifdef CONFIG_FOO",
- *   so that the file would not depend on CONFIG_FOO because the file defines
- *   this symbol itself.  But this optimization is bogus!  Consider this code:
- *   "#if 0 \n #define CONFIG_FOO \n #endif ... #ifdef CONFIG_FOO".  Here
- *   the definition is inactivated, but I still used it.  It turns out this
- *   actually happens a few times in the kernel source.  The simple way to
- *   fix this problem is to remove this particular optimization.
- *
- * 2.3.99-pre1, Andrew Morton <andrewm@uow.edu.au>
- * - Changed so that 'filename.o' depends upon 'filename.[cS]'.  This is so that
- *   missing source files are noticed, rather than silently ignored.
- *
- * 2.4.2-pre3, Keith Owens <kaos@ocs.com.au>
- * - Accept cflags followed by '--' followed by filenames.  mkdep extracts -I
- *   options from cflags and looks in the specified directories as well as the
- *   defaults.   Only -I is supported, no attempt is made to handle -idirafter,
- *   -isystem, -I- etc.
- */
-
-#include <ctype.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <sys/fcntl.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-
-
-char depname[512];
-int hasdep;
-
-struct path_struct {
-        int len;
-        char *buffer;
-};
-struct path_struct *path_array;
-int paths;
-
-
-/* Current input file */
-static const char *g_filename;
-
-/*
- * This records all the configuration options seen.
- * In perl this would be a hash, but here it's a long string
- * of values separated by newlines.  This is simple and
- * extremely fast.
- */
-char * str_config  = NULL;
-int    size_config = 0;
-int    len_config  = 0;
-
-static void
-do_depname(void)
-{
-        if (!hasdep) {
-                hasdep = 1;
-                if (g_filename) {
-                        /* Source file (*.[cS]) */
-                        printf("%s:", depname);
-                        printf(" %s", g_filename);
-                } else {
-                        /* header file (*.h) */
-                        printf("dep_%s +=", depname);
-                }
-        }
-}
-
-/*
- * Grow the configuration string to a desired length.
- * Usually the first growth is plenty.
- */
-void grow_config(int len)
-{
-        while (len_config + len > size_config) {
-                if (size_config == 0)
-                        size_config = 2048;
-                str_config = realloc(str_config, size_config *= 2);
-                if (str_config == NULL)
-                        { perror("malloc config"); exit(1); }
-        }
-}
-
-
-
-/*
- * Lookup a value in the configuration string.
- */
-int is_defined_config(const char * name, int len)
-{
-        const char * pconfig;
-        const char * plast = str_config + len_config - len;
-        for ( pconfig = str_config + 1; pconfig < plast; pconfig++ ) {
-                if (pconfig[ -1] == '\n'
-                &&  pconfig[len] == '\n'
-                &&  !memcmp(pconfig, name, len))
-                        return 1;
-        }
-        return 0;
-}
-
-
-
-/*
- * Add a new value to the configuration string.
- */
-void define_config(const char * name, int len)
-{
-        grow_config(len + 1);
-
-        memcpy(str_config+len_config, name, len);
-        len_config += len;
-        str_config[len_config++] = '\n';
-}
-
-
-
-/*
- * Clear the set of configuration strings.
- */
-void clear_config(void)
-{
-        len_config = 0;
-        define_config("", 0);
-}
-
-
-
-/*
- * This records all the precious .h filenames.  No need for a hash,
- * it's a long string of values enclosed in tab and newline.
- */
-char * str_precious  = NULL;
-int    size_precious = 0;
-int    len_precious  = 0;
-
-
-
-/*
- * Grow the precious string to a desired length.
- * Usually the first growth is plenty.
- */
-void grow_precious(int len)
-{
-        while (len_precious + len > size_precious) {
-                if (size_precious == 0)
-                        size_precious = 2048;
-                str_precious = realloc(str_precious, size_precious *= 2);
-                if (str_precious == NULL)
-                        { perror("malloc"); exit(1); }
-        }
-}
-
-
-
-/*
- * Add a new value to the precious string.
- */
-void define_precious(const char * filename)
-{
-        int len = strlen(filename);
-        grow_precious(len + 4);
-        *(str_precious+len_precious++) = '\t';
-        memcpy(str_precious+len_precious, filename, len);
-        len_precious += len;
-        memcpy(str_precious+len_precious, " \\\n", 3);
-        len_precious += 3;
-}
-
-
-
-/*
- * Handle an #include line.
- */
-void handle_include(int start, const char * name, int len)
-{
-        struct path_struct *path;
-        int i;
-
-        if (len == 14 && !memcmp(name, "include/config.h", len))
-                return;
-
-        if (len >= 7 && !memcmp(name, "config/", 7))
-                define_config(name+7, len-7-2);
-
-        for (i = start, path = path_array+start; i < paths; ++i, ++path) {
-                memcpy(path->buffer+path->len, name, len);
-                path->buffer[path->len+len] = '\0';
-                if (access(path->buffer, F_OK) == 0) {
-                        do_depname();
-                        printf(" \\\n %s $(dep_%s)", path->buffer, path->buffer);
-                        return;
-                }
-        }
-
-}
-
-
-
-/*
- * Add a path to the list of include paths.
- */
-void add_path(const char * name)
-{
-        struct path_struct *path;
-        char resolved_path[PATH_MAX+1];
-        const char *name2;
-
-        if (strcmp(name, ".")) {
-                name2 = realpath(name, resolved_path);
-                if (!name2) {
-                        fprintf(stderr, "realpath(%s) failed, %m\n", name);
-                        exit(1);
-                }
-        }
-        else {
-                name2 = "";
-        }
-
-        path_array = realloc(path_array, (++paths)*sizeof(*path_array));
-        if (!path_array) {
-                fprintf(stderr, "cannot expand path_arry\n");
-                exit(1);
-        }
-
-        path = path_array+paths-1;
-        path->len = strlen(name2);
-        path->buffer = malloc(path->len+1+256+1);
-        if (!path->buffer) {
-                fprintf(stderr, "cannot allocate path buffer\n");
-                exit(1);
-        }
-        strcpy(path->buffer, name2);
-        if (path->len && *(path->buffer+path->len-1) != '/') {
-                *(path->buffer+path->len) = '/';
-                *(path->buffer+(++(path->len))) = '\0';
-        }
-}
-
-
-
-/*
- * Record the use of a CONFIG_* word.
- */
-void use_config(const char * name, int len)
-{
-        char *pc;
-        int i;
-
-        pc = path_array[paths-1].buffer + path_array[paths-1].len;
-        memcpy(pc, "config/", 7);
-        pc += 7;
-
-        for (i = 0; i < len; i++) {
-            char c = name[i];
-            if (isupper((int)c)) c = tolower((int)c);
-            if (c == '_')   c = '/';
-            pc[i] = c;
-        }
-        pc[len] = '\0';
-
-        if (is_defined_config(pc, len))
-            return;
-
-        define_config(pc, len);
-
-        do_depname();
-        printf(" \\\n   $(wildcard %s.h)", path_array[paths-1].buffer);
-}
-
-
-
-/*
- * Macros for stunningly fast map-based character access.
- * __buf is a register which holds the current word of the input.
- * Thus, there is one memory access per sizeof(unsigned long) characters.
- */
-
-#if defined(__alpha__) || defined(__i386__) || defined(__ia64__)  || defined(__x86_64__) || defined(__MIPSEL__) \
-    || defined(__arm__)
-#define LE_MACHINE
-#endif
-
-#ifdef LE_MACHINE
-#define next_byte(x) (x >>= 8)
-#define current ((unsigned char) __buf)
-#else
-#define next_byte(x) (x <<= 8)
-#define current (__buf >> 8*(sizeof(unsigned long)-1))
-#endif
-
-#define GETNEXT { \
-        next_byte(__buf); \
-        if ((unsigned long) next % sizeof(unsigned long) == 0) { \
-                if (next >= end) \
-                        break; \
-                __buf = * (unsigned long *) next; \
-        } \
-        next++; \
-}
-
-/*
- * State machine macros.
- */
-#define CASE(c,label) if (current == c) goto label
-#define NOTCASE(c,label) if (current != c) goto label
-
-/*
- * Yet another state machine speedup.
- */
-#define MAX2(a,b) ((a)>(b)?(a):(b))
-#define MIN2(a,b) ((a)<(b)?(a):(b))
-#define MAX5(a,b,c,d,e) (MAX2(a,MAX2(b,MAX2(c,MAX2(d,e)))))
-#define MIN5(a,b,c,d,e) (MIN2(a,MIN2(b,MIN2(c,MIN2(d,e)))))
-
-
-
-/*
- * The state machine looks for (approximately) these Perl regular expressions:
- *
- *    m|\/\*.*?\*\/|
- *    m|\/\/.*|
- *    m|'.*?'|
- *    m|".*?"|
- *    m|#\s*include\s*"(.*?)"|
- *    m|#\s*include\s*<(.*?>"|
- *    m|#\s*(?define|undef)\s*CONFIG_(\w*)|
- *    m|(?!\w)CONFIG_|
- *
- * About 98% of the CPU time is spent here, and most of that is in
- * the 'start' paragraph.  Because the current characters are
- * in a register, the start loop usually eats 4 or 8 characters
- * per memory read.  The MAX5 and MIN5 tests dispose of most
- * input characters with 1 or 2 comparisons.
- */
-void state_machine(const char * map, const char * end)
-{
-        const char * next = map;
-        const char * map_dot;
-        unsigned long __buf = 0;
-
-        for (;;) {
-start:
-        GETNEXT
-__start:
-        if (current > MAX5('/','\'','"','#','C')) goto start;
-        if (current < MIN5('/','\'','"','#','C')) goto start;
-        CASE('/',  slash);
-        CASE('\'', squote);
-        CASE('"',  dquote);
-        CASE('#',  pound);
-        CASE('C',  cee);
-        goto start;
-
-/* // */
-slash_slash:
-        GETNEXT
-        CASE('\n', start);
-        NOTCASE('\\', slash_slash);
-        GETNEXT
-        goto slash_slash;
-
-/* / */
-slash:
-        GETNEXT
-        CASE('/',  slash_slash);
-        NOTCASE('*', __start);
-slash_star_dot_star:
-        GETNEXT
-__slash_star_dot_star:
-        NOTCASE('*', slash_star_dot_star);
-        GETNEXT
-        NOTCASE('/', __slash_star_dot_star);
-        goto start;
-
-/* '.*?' */
-squote:
-        GETNEXT
-        CASE('\'', start);
-        NOTCASE('\\', squote);
-        GETNEXT
-        goto squote;
-
-/* ".*?" */
-dquote:
-        GETNEXT
-        CASE('"', start);
-        NOTCASE('\\', dquote);
-        GETNEXT
-        goto dquote;
-
-/* #\s* */
-pound:
-        GETNEXT
-        CASE(' ',  pound);
-        CASE('\t', pound);
-        CASE('i',  pound_i);
-        CASE('d',  pound_d);
-        CASE('u',  pound_u);
-        goto __start;
-
-/* #\s*i */
-pound_i:
-        GETNEXT NOTCASE('n', __start);
-        GETNEXT NOTCASE('c', __start);
-        GETNEXT NOTCASE('l', __start);
-        GETNEXT NOTCASE('u', __start);
-        GETNEXT NOTCASE('d', __start);
-        GETNEXT NOTCASE('e', __start);
-        goto pound_include;
-
-/* #\s*include\s* */
-pound_include:
-        GETNEXT
-        CASE(' ',  pound_include);
-        CASE('\t', pound_include);
-        map_dot = next;
-        CASE('"',  pound_include_dquote);
-        CASE('<',  pound_include_langle);
-        goto __start;
-
-/* #\s*include\s*"(.*)" */
-pound_include_dquote:
-        GETNEXT
-        CASE('\n', start);
-        NOTCASE('"', pound_include_dquote);
-        handle_include(0, map_dot, next - map_dot - 1);
-        goto start;
-
-/* #\s*include\s*<(.*)> */
-pound_include_langle:
-        GETNEXT
-        CASE('\n', start);
-        NOTCASE('>', pound_include_langle);
-        handle_include(1, map_dot, next - map_dot - 1);
-        goto start;
-
-/* #\s*d */
-pound_d:
-        GETNEXT NOTCASE('e', __start);
-        GETNEXT NOTCASE('f', __start);
-        GETNEXT NOTCASE('i', __start);
-        GETNEXT NOTCASE('n', __start);
-        GETNEXT NOTCASE('e', __start);
-        goto pound_define_undef;
-
-/* #\s*u */
-pound_u:
-        GETNEXT NOTCASE('n', __start);
-        GETNEXT NOTCASE('d', __start);
-        GETNEXT NOTCASE('e', __start);
-        GETNEXT NOTCASE('f', __start);
-        goto pound_define_undef;
-
-/*
- * #\s*(define|undef)\s*CONFIG_(\w*)
- *
- * this does not define the word, because it could be inside another
- * conditional (#if 0).  But I do parse the word so that this instance
- * does not count as a use.  -- mec
- */
-pound_define_undef:
-        GETNEXT
-        CASE(' ',  pound_define_undef);
-        CASE('\t', pound_define_undef);
-
-                NOTCASE('C', __start);
-        GETNEXT NOTCASE('O', __start);
-        GETNEXT NOTCASE('N', __start);
-        GETNEXT NOTCASE('F', __start);
-        GETNEXT NOTCASE('I', __start);
-        GETNEXT NOTCASE('G', __start);
-        GETNEXT NOTCASE('_', __start);
-
-        map_dot = next;
-pound_define_undef_CONFIG_word:
-        GETNEXT
-        if (isalnum(current) || current == '_')
-                goto pound_define_undef_CONFIG_word;
-        goto __start;
-
-/* \<CONFIG_(\w*) */
-cee:
-        if (next >= map+2 && (isalnum((int)next[-2]) || next[-2] == '_'))
-                goto start;
-        GETNEXT NOTCASE('O', __start);
-        GETNEXT NOTCASE('N', __start);
-        GETNEXT NOTCASE('F', __start);
-        GETNEXT NOTCASE('I', __start);
-        GETNEXT NOTCASE('G', __start);
-        GETNEXT NOTCASE('_', __start);
-
-        map_dot = next;
-cee_CONFIG_word:
-        GETNEXT
-        if (isalnum(current) || current == '_')
-                goto cee_CONFIG_word;
-        use_config(map_dot, next - map_dot - 1);
-        goto __start;
-    }
-}
-
-
-
-/*
- * Generate dependencies for one file.
- */
-void do_depend(const char * filename)
-{
-        int mapsize;
-        int pagesizem1 = getpagesize()-1;
-        int fd;
-        struct stat st;
-        char * map;
-
-        fd = open(filename, O_RDONLY);
-        if (fd < 0) {
-                perror(filename);
-                return;
-        }
-
-        fstat(fd, &st);
-        if (st.st_size == 0) {
-                fprintf(stderr,"%s is empty\n",filename);
-                close(fd);
-                return;
-        }
-
-        mapsize = st.st_size;
-        mapsize = (mapsize+pagesizem1) & ~pagesizem1;
-        map = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, fd, 0);
-        if ((long) map == -1) {
-                perror("mkdep: mmap");
-                close(fd);
-                return;
-        }
-        if ((unsigned long) map % sizeof(unsigned long) != 0)
-        {
-                fprintf(stderr, "do_depend: map not aligned\n");
-                exit(1);
-        }
-
-        hasdep = 0;
-        clear_config();
-        state_machine(map, map+st.st_size);
-        if (hasdep) {
-                puts("");
-        }
-
-        munmap(map, mapsize);
-        close(fd);
-}
-
-
-
-/*
- * Generate dependencies for all files.
- */
-int main(int argc, char **argv)
-{
-        int len;
-        const char *hpath;
-
-        hpath = getenv("TOPDIR");
-        if (!hpath) {
-                fputs("mkdep: TOPDIR not set in environment.  "
-                      "Don't bypass the top level Makefile.\n", stderr);
-                return 1;
-        }
-
-        add_path(".");          /* for #include "..." */
-
-        while (++argv, --argc > 0) {
-                if (strncmp(*argv, "-I", 2) == 0) {
-                        if (*((*argv)+2)) {
-                                add_path((*argv)+2);
-                        }
-                        else {
-                                ++argv;
-                                --argc;
-                                add_path(*argv);
-                        }
-                }
-                else if (strcmp(*argv, "--") == 0) {
-                        break;
-                }
-        }
-
-        add_path(hpath);        /* must be last entry, for config files */
-
-        while (--argc > 0) {
-                const char * filename = *++argv;
-                g_filename = 0;
-                len = strlen(filename);
-                memcpy(depname, filename, len+1);
-                if (len > 2 && filename[len-2] == '.') {
-                        if (filename[len-1] == 'c' || filename[len-1] == 'S') {
-                            depname[len-1] = 'o';
-                            g_filename = filename;
-                        }
-                }
-                do_depend(filename);
-        }
-        if (len_precious) {
-                *(str_precious+len_precious) = '\0';
-                printf(".PRECIOUS:%s\n", str_precious);
-        }
-        return 0;
-}
diff --git a/scripts/split-include.c b/scripts/split-include.c
deleted file mode 100644
index 624a0d62b..000000000
--- a/scripts/split-include.c
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
- * split-include.c
- *
- * Copyright abandoned, Michael Chastain, <mailto:mec@shout.net>.
- * This is a C version of syncdep.pl by Werner Almesberger.
- *
- * This program takes autoconf.h as input and outputs a directory full
- * of one-line include files, merging onto the old values.
- *
- * Think of the configuration options as key-value pairs.  Then there
- * are five cases:
- *
- *    key      old value   new value   action
- *
- *    KEY-1    VALUE-1     VALUE-1     leave file alone
- *    KEY-2    VALUE-2A    VALUE-2B    write VALUE-2B into file
- *    KEY-3    -           VALUE-3     write VALUE-3  into file
- *    KEY-4    VALUE-4     -           write an empty file
- *    KEY-5    (empty)     -           leave old empty file alone
- */
-
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#define ERROR_EXIT(strExit)                                             \
-    {                                                                   \
-        const int errnoSave = errno;                                    \
-        fprintf(stderr, "%s: ", str_my_name);                           \
-        errno = errnoSave;                                              \
-        perror((strExit));                                              \
-        exit(1);                                                        \
-    }
-
-
-
-int main(int argc, const char * argv [])
-{
-    const char * str_my_name;
-    const char * str_file_autoconf;
-    const char * str_dir_config;
-
-    FILE * fp_config;
-    FILE * fp_target;
-    FILE * fp_find;
-
-    int buffer_size;
-
-    char * line;
-    char * old_line;
-    char * list_target;
-    char * ptarget;
-
-    struct stat stat_buf;
-
-    /* Check arg count. */
-    if (argc != 3)
-    {
-        fprintf(stderr, "%s: wrong number of arguments.\n", argv[0]);
-        exit(1);
-    }
-
-    str_my_name       = argv[0];
-    str_file_autoconf = argv[1];
-    str_dir_config    = argv[2];
-
-    /* Find a buffer size. */
-    if (stat(str_file_autoconf, &stat_buf) != 0)
-        ERROR_EXIT(str_file_autoconf);
-    buffer_size = 2 * stat_buf.st_size + 4096;
-
-    /* Allocate buffers. */
-    if ( (line        = malloc(buffer_size)) == NULL
-    ||   (old_line    = malloc(buffer_size)) == NULL
-    ||   (list_target = malloc(buffer_size)) == NULL )
-        ERROR_EXIT(str_file_autoconf);
-
-    /* Open autoconfig file. */
-    if ((fp_config = fopen(str_file_autoconf, "r")) == NULL)
-        ERROR_EXIT(str_file_autoconf);
-
-    /* Make output directory if needed. */
-    if (stat(str_dir_config, &stat_buf) != 0)
-    {
-        if (mkdir(str_dir_config, 0755) != 0)
-            ERROR_EXIT(str_dir_config);
-    }
-
-    /* Change to output directory. */
-    if (chdir(str_dir_config) != 0)
-        ERROR_EXIT(str_dir_config);
-
-    /* Put initial separator into target list. */
-    ptarget = list_target;
-    *ptarget++ = '\n';
-
-    /* Read config lines. */
-    while (fgets(line, buffer_size, fp_config))
-    {
-        const char * str_config;
-        int is_same;
-        int itarget;
-
-        if (line[0] != '#')
-            continue;
-        if ((str_config = strstr(line, "CONFIG_")) == NULL)
-            continue;
-
-        /* Make the output file name. */
-        str_config += sizeof("CONFIG_") - 1;
-        for (itarget = 0; !isspace(str_config[itarget]); itarget++)
-        {
-            char c = str_config[itarget];
-            if (isupper(c)) c = tolower(c);
-            if (c == '_')   c = '/';
-            ptarget[itarget] = c;
-        }
-        ptarget[itarget++] = '.';
-        ptarget[itarget++] = 'h';
-        ptarget[itarget++] = '\0';
-
-        /* Check for existing file. */
-        is_same = 0;
-        if ((fp_target = fopen(ptarget, "r")) != NULL)
-        {
-            fgets(old_line, buffer_size, fp_target);
-            if (fclose(fp_target) != 0)
-                ERROR_EXIT(ptarget);
-            if (!strcmp(line, old_line))
-                is_same = 1;
-        }
-
-        if (!is_same)
-        {
-            /* Auto-create directories. */
-            int islash;
-            for (islash = 0; islash < itarget; islash++)
-            {
-                if (ptarget[islash] == '/')
-                {
-                    ptarget[islash] = '\0';
-                    if (stat(ptarget, &stat_buf) != 0
-                    &&  mkdir(ptarget, 0755)     != 0)
-                        ERROR_EXIT( ptarget );
-                    ptarget[islash] = '/';
-                }
-            }
-
-            /* Write the file. */
-            if ((fp_target = fopen(ptarget, "w" )) == NULL)
-                ERROR_EXIT(ptarget);
-            fputs(line, fp_target);
-            if (ferror(fp_target) || fclose(fp_target) != 0)
-                ERROR_EXIT(ptarget);
-        }
-
-        /* Update target list */
-        ptarget += itarget;
-        *(ptarget-1) = '\n';
-    }
-
-    /*
-     * Close autoconfig file.
-     * Terminate the target list.
-     */
-    if (fclose(fp_config) != 0)
-        ERROR_EXIT(str_file_autoconf);
-    *ptarget = '\0';
-
-    /*
-     * Fix up existing files which have no new value.
-     * This is Case 4 and Case 5.
-     *
-     * I re-read the tree and filter it against list_target.
-     * This is crude.  But it avoids data copies.  Also, list_target
-     * is compact and contiguous, so it easily fits into cache.
-     *
-     * Notice that list_target contains strings separated by \n,
-     * with a \n before the first string and after the last.
-     * fgets gives the incoming names a terminating \n.
-     * So by having an initial \n, strstr will find exact matches.
-     */
-
-    fp_find = popen("find * -type f -name \"*.h\" -print", "r");
-    if (fp_find == 0)
-        ERROR_EXIT( "find" );
-
-    line[0] = '\n';
-    while (fgets(line+1, buffer_size, fp_find))
-    {
-        if (strstr(list_target, line) == NULL)
-        {
-            /*
-             * This is an old file with no CONFIG_* flag in autoconf.h.
-             */
-
-            /* First strip the \n. */
-            line[strlen(line)-1] = '\0';
-
-            /* Grab size. */
-            if (stat(line+1, &stat_buf) != 0)
-                ERROR_EXIT(line);
-
-            /* If file is not empty, make it empty and give it a fresh date. */
-            if (stat_buf.st_size != 0)
-            {
-                if ((fp_target = fopen(line+1, "w")) == NULL)
-                    ERROR_EXIT(line);
-                if (fclose(fp_target) != 0)
-                    ERROR_EXIT(line);
-            }
-        }
-    }
-
-    if (pclose(fp_find) != 0)
-        ERROR_EXIT("find");
-
-    return 0;
-}