/* $NetBSD: mkdep.c,v 1.47 2021/08/20 05:45:19 rillig Exp $ */

/*-
* Copyright (c) 1999 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Matthias Scheler.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#if HAVE_NBTOOL_CONFIG_H
#include "nbtool_config.h"
#endif

#include <sys/cdefs.h>
#if !defined(lint)
__COPYRIGHT("@(#) Copyright (c) 1999 The NetBSD Foundation, Inc.\
All rights reserved.");
__RCSID("$NetBSD: mkdep.c,v 1.47 2021/08/20 05:45:19 rillig Exp $");
#endif /* not lint */

#include <sys/mman.h>
#include <sys/param.h>
#include <sys/wait.h>
#include <ctype.h>
#include <err.h>
#include <fcntl.h>
#include <getopt.h>
#include <locale.h>
#include <paths.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "findcc.h"

typedef struct opt opt_t;
struct opt {
       opt_t   *left;
       opt_t   *right;
       int     len;
       int     count;
       char    name[4];
};

typedef struct suff_list {
       size_t  len;
       char    *suff;
       struct suff_list *next;
} suff_list_t;

/* tree of includes for -o processing */
static opt_t *opt;
static int width;
static int verbose;

#define DEFAULT_PATH            _PATH_DEFPATH
#define DEFAULT_FILENAME        ".depend"

static void save_for_optional(const char *, const char *);
static size_t write_optional(int, opt_t *, size_t);

__dead static void
usage(void)
{
       (void)fprintf(stderr,
           "usage: %s [-aDdiopqv] [-f file] [-P prefix] [-s suffixes] "
           "-- [flags] file ...\n",
           getprogname());
       exit(EXIT_FAILURE);
}

static int
run_cc(int argc, char **argv, const char **fname)
{
       const char *CC;
       const char *tmpdir;
       char * volatile pathname;
       static char tmpfilename[MAXPATHLEN];
       char **args;
       int tmpfd;
       pid_t pid, cpid;
       int status;

       if ((CC = getenv("CC")) == NULL)
               CC = DEFAULT_CC;
       if ((pathname = findcc(CC)) == NULL)
               if (!setenv("PATH", DEFAULT_PATH, 1))
                       pathname = findcc(CC);
       if (pathname == NULL)
               err(EXIT_FAILURE, "%s: not found", CC);
       if ((args = malloc((argc + 3) * sizeof(char *))) == NULL)
               err(EXIT_FAILURE, "malloc");

       args[0] = __UNCONST(CC);
       args[1] = __UNCONST("-M");
       (void)memcpy(&args[2], argv, (argc + 1) * sizeof(char *));

       if ((tmpdir = getenv("TMPDIR")) == NULL)
               tmpdir = _PATH_TMP;
       (void)snprintf(tmpfilename, sizeof (tmpfilename), "%s/%s", tmpdir,
           "mkdepXXXXXX");
       if ((tmpfd = mkstemp(tmpfilename)) < 0)
               err(EXIT_FAILURE,  "Unable to create temporary file %s",
                   tmpfilename);
       (void)unlink(tmpfilename);
       *fname = tmpfilename;

       if (verbose) {
               char **a;
               for (a = args; *a; a++)
                       printf("%s ", *a);
               printf("\n");
       }

       switch (cpid = vfork()) {
       case 0:
               (void)dup2(tmpfd, STDOUT_FILENO);
               (void)close(tmpfd);

               (void)execv(pathname, args);
               _exit(EXIT_FAILURE);
               /* NOTREACHED */

       case -1:
               err(EXIT_FAILURE, "unable to fork");
       }

       free(pathname);
       free(args);

       while (((pid = wait(&status)) != cpid) && (pid >= 0))
               continue;

       if (status)
               errx(EXIT_FAILURE, "compile failed.");

       return tmpfd;
}

static const char *
read_fname(void)
{
       static char *fbuf;
       static int fbuflen;
       int len, ch;

       for (len = 0; (ch = getchar()) != EOF; len++) {
               if (isspace(ch)) {
                       if (len != 0)
                               break;
                       len--;
                       continue;
               }
               if (len >= fbuflen - 1) {
                       fbuf = realloc(fbuf, fbuflen += 32);
                       if (fbuf == NULL)
                               err(EXIT_FAILURE, "no memory");
               }
               fbuf[len] = ch;
       }
       if (len == 0)
               return NULL;
       fbuf[len] = 0;
       return fbuf;
}

static struct option longopt[] = {
       { "sysroot", 1, NULL, 'R' },
       { NULL, 0, NULL, '\0' },
};

static void
addsuff(suff_list_t **l, const char *s, size_t len)
{
       suff_list_t *p = calloc(1, sizeof(*p));
       if (p == NULL)
               err(1, "calloc");
       p->suff = malloc(len + 1);
       if (p->suff == NULL)
               err(1, "malloc");
       memcpy(p->suff, s, len);
       p->suff[len] = '\0';
       p->len = len;
       p->next = *l;
       *l = p;
}

int
main(int argc, char **argv)
{
       int     aflag, dflag, iflag, oflag, qflag;
       const char *filename;
       int     dependfile;
       char    *buf, *lim, *ptr, *line, *suf, *colon, *eol;
       int     ok_ind, ch;
       size_t  sz;
       int     fd;
       size_t  slen;
       const char *fname;
       const char *prefix = NULL;
       const char *suffixes = NULL, *s;
       suff_list_t *suff_list = NULL, *sl;

       suf = NULL;             /* XXXGCC -Wuninitialized [sun2] */
       sl = NULL;              /* XXXGCC -Wuninitialized [sun2] */

       setlocale(LC_ALL, "");
       setprogname(argv[0]);

       aflag = O_WRONLY | O_APPEND | O_CREAT | O_TRUNC;
       dflag = 0;
       iflag = 0;
       oflag = 0;
       qflag = 0;
       filename = DEFAULT_FILENAME;
       dependfile = -1;

       opterr = 0;     /* stop getopt() bleating about errors. */
       for (;;) {
               ok_ind = optind;
               ch = getopt_long(argc, argv, "aDdf:ioP:pqRs:v", longopt, NULL);
               switch (ch) {
               case -1:
                       ok_ind = optind;
                       break;
               case 'a':       /* Append to output file */
                       aflag &= ~O_TRUNC;
                       continue;
               case 'D':       /* Process *.d files (don't run cc -M) */
                       dflag = 2;      /* Read names from stdin */
                       opterr = 1;
                       continue;
               case 'd':       /* Process *.d files (don't run cc -M) */
                       dflag = 1;
                       opterr = 1;
                       continue;
               case 'f':       /* Name of output file */
                       filename = optarg;
                       continue;
               case 'i':
                       iflag = 1;
                       continue;
               case 'o':       /* Mark dependent files .OPTIONAL */
                       oflag = 1;
                       continue;
               case 'P':       /* Prefix for each target filename */
                       prefix = optarg;
                       continue;
               case 'p':       /* Program mode (x.o: -> x:) */
                       suffixes = "";
                       continue;
               case 'q':       /* Quiet */
                       qflag = 1;
                       continue;
               case 'R':
                       /* sysroot = optarg */
                       continue;
               case 's':       /* Suffix list */
                       suffixes = optarg;
                       continue;
               case 'v':
                       verbose = 1;
                       continue;
               default:
                       if (dflag)
                               usage();
                       /* Unknown arguments are passed to "${CC} -M" */
                       break;
               }
               break;
       }

       argc -= ok_ind;
       argv += ok_ind;
       if ((argc == 0 && !dflag) || (argc != 0 && dflag == 2))
               usage();

       if (suffixes != NULL) {
               if (*suffixes) {
                       for (s = suffixes; (sz = strcspn(s, ", ")) != 0;) {
                               addsuff(&suff_list, s, sz);
                               s += sz;
                               while (*s && strchr(", ", *s))
                                       s++;
                       }
               } else
                       addsuff(&suff_list, "", 0);
       }

       dependfile = open(filename, aflag, 0666);
       if (dependfile == -1)
               goto wrerror;

       while (dflag == 2 || *argv != NULL) {
               if (dflag) {
                       if (dflag == 2) {
                               fname = read_fname();
                               if (fname == NULL)
                                       break;
                       } else
                               fname = *argv++;
                       if (iflag) {
                               if (dprintf(dependfile, ".-include \"%s\"\n",
                                   fname) < 0)
                                       goto wrerror;
                               continue;
                       }
                       fd = open(fname, O_RDONLY, 0);
                       if (fd == -1) {
                               if (!qflag)
                                       warn("ignoring %s", fname);
                               continue;
                       }
               } else {
                       fd = run_cc(argc, argv, &fname);
                       /* consume all args... */
                       argv += argc;
               }

               sz = lseek(fd, 0, SEEK_END);
               if (sz == 0) {
                       close(fd);
                       continue;
               }
               buf = mmap(NULL, sz, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
               close(fd);

               if (buf == MAP_FAILED)
                       err(EXIT_FAILURE, "unable to mmap file %s", fname);
               lim = buf + sz - 1;

               /* Remove leading "./" from filenames */
               for (ptr = buf; ptr < lim; ptr++) {
                       if (ptr[1] != '.' || ptr[2] != '/'
                           || !isspace((unsigned char)ptr[0]))
                               continue;
                       ptr[1] = ' ';
                       ptr[2] = ' ';
               }

               for (line = eol = buf; eol <= lim;) {
                       while (eol <= lim && *eol++ != '\n')
                               /* Find end of this line */
                               continue;
                       if (line == eol - 1) {
                               /* empty line - ignore */
                               line = eol;
                               continue;
                       }
                       if (eol[-2] == '\\')
                               /* Assemble continuation lines */
                               continue;
                       for (colon = line; *colon != ':'; colon++) {
                               if (colon >= eol) {
                                       colon = NULL;
                                       break;
                               }
                       }
                       if (isspace((unsigned char)*line) || colon == NULL) {
                               /* No dependency - just transcribe line */
                               if (write(dependfile, line, eol - line) < 0)
                                       goto wrerror;
                               line = eol;
                               continue;
                       }
                       if (suff_list != NULL) {
                               /* Find the .o: */
                               /* First allow for any whitespace */
                               for (suf = colon; suf > buf; suf--) {
                                       if (!isspace((unsigned char)suf[-1]))
                                               break;
                               }
                               if (suf == buf)
                                       errx(EXIT_FAILURE,
                                           "Corrupted file `%s'", fname);
                               /* Then look for any valid suffix */
                               for (sl = suff_list; sl != NULL;
                                   sl = sl->next) {
                                       if (sl->len && buf <= suf - sl->len &&
                                           !memcmp(suf - sl->len, sl->suff,
                                                   sl->len))
                                               break;
                               }
                               /*
                                * Not found, check for .o, since the
                                * original file will have it.
                                */
                               if (sl == NULL) {
                                       if (memcmp(suf - 2, ".o", 2) == 0)
                                               slen = 2;
                                       else
                                               slen = 0;
                               } else
                                       slen = sl->len;
                       }
                       if (suff_list != NULL && slen != 0) {
                               suf -= slen;
                               for (sl = suff_list; sl != NULL; sl = sl->next)
                               {
                                       if (sl != suff_list)
                                               if (write(dependfile, " ", 1)
                                                   < 0)
                                                       goto wrerror;
                                       if (prefix != NULL)
                                               if (write(dependfile, prefix,
                                                   strlen(prefix)) < 0)
                                                       goto wrerror;
                                       if (write(dependfile, line,
                                           suf - line) < 0)
                                               goto wrerror;
                                       if (write(dependfile, sl->suff,
                                           sl->len) < 0)
                                               goto wrerror;
                               }
                               if (write(dependfile, colon, eol - colon) < 0)
                                       goto wrerror;
                       } else {
                               if (prefix != NULL)
                                       if (write(dependfile, prefix,
                                           strlen(prefix)) < 0)
                                               goto wrerror;
                               if (write(dependfile, line, eol - line) < 0)
                                       goto wrerror;
                       }

                       if (oflag)
                               save_for_optional(colon + 1, eol);
                       line = eol;
               }
               munmap(buf, sz);
       }

       if (oflag && opt != NULL) {
               if (write(dependfile, ".OPTIONAL:", 10) < 0)
                       goto wrerror;
               width = 9;
               sz = write_optional(dependfile, opt, 0);
               if (sz == (size_t)-1)
                       goto wrerror;
               /* 'depth' is about 39 for an i386 kernel */
               /* fprintf(stderr, "Recursion depth %d\n", sz); */
       }
       close(dependfile);

       exit(EXIT_SUCCESS);
wrerror:
       err(EXIT_FAILURE, "unable to %s to file %s",
           aflag & O_TRUNC ? "write" : "append", filename);
}


/*
* Only save each file once - the kernel .depend is 3MB and there is
* no point doubling its size.
* The data seems to be 'random enough' so the simple binary tree
* only has a reasonable depth.
*/
static void
save_for_optional(const char *start, const char *limit)
{
       opt_t **l, *n;
       const char *name, *end;
       int c;

       while (start < limit && strchr(" \t\n\\", *start))
               start++;
       for (name = start; ; name = end) {
               while (name < limit && strchr(" \t\n\\", *name))
                       name++;
               for (end = name; end < limit && !strchr(" \t\n\\", *end);)
                       end++;
               if (name >= limit)
                       break;
               if (end[-1] == 'c' && end[-2] == '.' && name == start)
                       /* ignore dependency on the files own .c */
                       continue;
               for (l = &opt;;) {
                       n = *l;
                       if (n == NULL) {
                               n = malloc(sizeof *n + (end - name));
                               n->left = n->right = 0;
                               n->len = end - name;
                               n->count = 1;
                               n->name[0] = ' ';
                               memcpy(n->name + 1, name, end - name);
                               *l = n;
                               break;
                       }
                       c = (end - name) - n->len;
                       if (c == 0)
                               c = memcmp(n->name + 1, name, (end - name));
                       if (c == 0) {
                               /* Duplicate */
                               n->count++;
                               break;
                       }
                       if (c < 0)
                               l = &n->left;
                       else
                               l = &n->right;
               }
       }
}

static size_t
write_optional(int fd, opt_t *node, size_t depth)
{
       size_t d1 = ++depth;

       if (node->left)
               d1 = write_optional(fd, node->left, d1);
       if (width > 76 - node->len) {
               if (write(fd, " \\\n ", 4) < 0)
                       return (size_t)-1;
               width = 1;
       }
       width += 1 + node->len;
       if (write(fd, node->name, 1 + node->len) < 0)
               return (size_t)-1;
       if (node->right)
               depth = write_optional(fd, node->right, depth);
       return d1 > depth ? d1 : depth;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.