示例#1
0
void
recursive_pr_include(struct inclist *head, const char *file, const char *base)
{
	int	i;

	if (head->i_flags & MARKED)
		return;
	head->i_flags |= MARKED;
	if (head->i_file != file)
		pr(head, file, base);
	for (i=0; i<head->i_listlen; i++)
		recursive_pr_include(head->i_list[ i ], file, base);
}
示例#2
0
int main (int argc, char **argv)
{
    register char **fp = filelist;
    register char **incp = includedirs;
    register char *p;
    register struct inclist *ip;
    char *makefile = NULL;
    struct filepointer *filecontent;
    struct symtab *psymp = predefs;
    const char *endmarker = NULL;
    char *defincdir = NULL;
    char **undeflist = NULL;
    int i, numundefs = 0;

#if defined (INITIALIZE)	// initialization code
    INITIALIZE;
#endif

    ProgramName = argv[0];

    while (psymp->s_name)
    {
        define2 (psymp->s_name, psymp->s_value, &maininclist);
        psymp++;
    }
    if (argc == 2 && argv[1][0] == '@')
    {
        struct stat ast;
        int afd;
        char *args;
        char **nargv;
        int nargc;
        char quotechar = '\0';

        nargc = 1;
        if ((afd = open (argv[1] + 1, O_RDONLY)) < 0)
            fatalerr ("cannot open \"%s\"\n", argv[1] + 1);
        fstat (afd, &ast);
        args = (char *) malloc (ast.st_size + 1);
        if ((ast.st_size = read (afd, args, ast.st_size)) < 0)
            fatalerr ("failed to read %s\n", argv[1] + 1);
        args[ast.st_size] = '\0';
        close (afd);
        for (p = args; *p; p++)
        {
            if (quotechar)
            {
                if (quotechar == '\\' ||
                    (*p == quotechar && p[-1] != '\\'))
                    quotechar = '\0';
                continue;
            }
            switch (*p)
            {
                case '\\':
                case '"':
                case '\'':
                    quotechar = *p;
                    break;
                case ' ':
                case '\n':
                    *p = '\0';
                    if (p > args && p[-1])
                        nargc++;
                    break;
            }
        }
        if (p[-1])
            nargc++;
        nargv = (char **) malloc (nargc * sizeof (char *));

        nargv[0] = argv[0];
        argc = 1;
        for (p = args; argc < nargc; p += strlen (p) + 1)
            if (*p)
                nargv[argc++] = p;
        argv = nargv;
    }
    for (argc--, argv++; argc; argc--, argv++)
    {
        /* if looking for endmarker then check before parsing */
        if (endmarker && strcmp (endmarker, *argv) == 0)
        {
            endmarker = NULL;
            continue;
        }
        if (**argv != '-')
        {
            /* treat +thing as an option for C++ */
            if (endmarker && **argv == '+')
                continue;
            *fp++ = argv[0];
            continue;
        }
        switch (argv[0][1])
        {
            case '-':
                endmarker = &argv[0][2];
                if (endmarker[0] == '\0')
                    endmarker = "--";
                break;
            case 'D':
                if (argv[0][2] == '\0')
                {
                    argv++;
                    argc--;
                }
                for (p = argv[0] + 2; *p; p++)
                    if (*p == '=')
                    {
                        *p = ' ';
                        break;
                    }
                define (argv[0] + 2, &maininclist);
                break;
            case 'I':
                if (incp >= includedirs + MAXDIRS)
                    fatalerr ("Too many -I flags.\n");
                *incp++ = argv[0] + 2;
                if (**(incp - 1) == '\0')
                {
                    *(incp - 1) = *(++argv);
                    argc--;
                }
                break;
            case 'U':
                /* Undef's override all -D's so save them up */
                numundefs++;
                if (numundefs == 1)
                    undeflist = (char **)malloc (sizeof (char *));
                else
                    undeflist = (char **)realloc (undeflist, numundefs * sizeof (char *));

                if (argv[0][2] == '\0')
                {
                    argv++;
                    argc--;
                }
                undeflist[numundefs - 1] = argv[0] + 2;
                break;
            case 'Y':
                defincdir = argv[0] + 2;
                break;
                /* do not use if endmarker processing */
            case 'a':
                if (endmarker)
                    break;
                opt_append = true;
                break;
            case 'b':
                if (endmarker)
                    break;
                opt_backup = true;
                break;
            case 'c':
                if (endmarker)
                    break;
                opt_create = true;
                break;
            case 'r':
                if (endmarker)
                    break;
                opt_remove_prefix = true;
                break;
            case 'w':
                if (endmarker)
                    break;
                if (argv[0][2] == '\0')
                {
                    argv++;
                    argc--;
                    width = atoi (argv[0]);
                }
                else
                    width = atoi (argv[0] + 2);
                break;
            case 'o':
                if (endmarker)
                    break;
                if (argv[0][2] == '\0')
                {
                    argv++;
                    argc--;
                    objsuffix = argv[0];
                }
                else
                    objsuffix = argv[0] + 2;
                break;
            case 'p':
                if (endmarker)
                    break;
                if (argv[0][2] == '\0')
                {
                    argv++;
                    argc--;
                    objprefix = argv[0];
                }
                else
                    objprefix = argv[0] + 2;
                break;
            case 'S':
                if (endmarker)
                    break;
                opt_sysincludes = true;
                break;
            case 'v':
                if (endmarker)
                    break;
                opt_verbose = true;
#ifdef CS_DEBUG
                if (argv[0][2])
                    _debugmask = atoi (argv[0] + 2);
#endif
                break;
            case 's':
                if (endmarker)
                    break;
                startat = argv[0] + 2;
                if (*startat == '\0')
                {
                    startat = *(++argv);
                    argc--;
                }
                if (*startat != '#')
                    fatalerr ("-s flag's value should start %s\n",
                              "with '#'.");
                break;
            case 'f':
                if (endmarker)
                    break;
                makefile = argv[0] + 2;
                if (*makefile == '\0')
                {
                    makefile = *(++argv);
                    argc--;
                }
                break;

            case 'm':
                opt_warn_multiple = true;
                break;

                /* Ignore -O, -g so we can just pass ${CFLAGS} to
                 makedepend
                 */
            case 'O':
            case 'g':
                break;
            case 'h':
                if (endmarker)
                    break;
                display_help ();
                return 0;
            case 'V':
                if (endmarker)
                    break;
                display_version ();
                return 0;
            default:
                if (endmarker)
                    break;
                /* fatalerr("unknown opt = %s\n", argv[0]); */
                warning ("ignoring option %s\n", argv[0]);
        }
    }
    /* Now do the undefs from the command line */
    for (i = 0; i < numundefs; i++)
        undefine (undeflist[i], &maininclist);
    if (numundefs > 0)
        free (undeflist);

    if (!defincdir)
    {
#ifdef PREINCDIR
        add_include (PREINCDIR, incp);
#endif
#if defined (__GNUC__) || defined (_WIN32)
        add_include (
#  if defined (__GNUC__)
       getenv ("C_INCLUDE_PATH"),
#  else
       getenv ("INCLUDE"),
#  endif
       incp);
#else /* !__GNUC__, does not use INCLUDEDIR at all */
        if (incp >= includedirs + MAXDIRS)
            fatalerr ("Too many -I flags.\n");
        *incp++ = INCLUDEDIR;
#endif

#ifdef POSTINCDIR
        add_include (POSTINCDIR, incp);
#endif
    }
    else if (*defincdir)
        add_include (defincdir, incp);

    /* if nothing to do, abort */
    if (!*filelist)
        fatalerr ("No files specified, try \"makedep -h\"\n");

    redirect (startat, makefile);

    /* catch signals */
#ifdef USGISH
    /*  should really reset SIGINT to SIG_IGN if it was.  */
#ifdef SIGHUP
    signal (SIGHUP, sighandler);
#endif
    signal (SIGINT, sighandler);
#ifdef SIGQUIT
    signal (SIGQUIT, sighandler);
#endif
    signal (SIGILL, sighandler);
#ifdef SIGBUS
    signal (SIGBUS, sighandler);
#endif
    signal (SIGSEGV, sighandler);
#ifdef SIGSYS
    signal (SIGSYS, sighandler);
#endif
#else
    sig_act.sa_handler = sighandler;
#ifdef _POSIX_SOURCE
    sigemptyset (&sig_act.sa_mask);
    sigaddset (&sig_act.sa_mask, SIGINT);
    sigaddset (&sig_act.sa_mask, SIGQUIT);
#ifdef SIGBUS
    sigaddset (&sig_act.sa_mask, SIGBUS);
#endif
    sigaddset (&sig_act.sa_mask, SIGILL);
    sigaddset (&sig_act.sa_mask, SIGSEGV);
    sigaddset (&sig_act.sa_mask, SIGHUP);
    sigaddset (&sig_act.sa_mask, SIGPIPE);
#ifdef SIGSYS
    sigaddset (&sig_act.sa_mask, SIGSYS);
#endif
#else
    sig_act.sa_mask = ((1 << (SIGINT - 1))
#ifdef SIGQUIT
                       | (1 << (SIGQUIT - 1))
#endif
#ifdef SIGBUS
                       | (1 << (SIGBUS - 1))
#endif
                       | (1 << (SIGILL - 1))
                       | (1 << (SIGSEGV - 1))
#ifdef SIGHUP
                       | (1 << (SIGHUP - 1))
#endif
#ifdef SIGPIPE
                       | (1 << (SIGPIPE - 1))
#endif
#ifdef SIGSYS
                       | (1 << (SIGSYS - 1))
#endif
                      );
#endif /* _POSIX_SOURCE */
    sig_act.sa_flags = 0;
#ifdef SIGHUP
    sigaction (SIGHUP, &sig_act, (struct sigaction *) 0);
#endif
    sigaction (SIGINT, &sig_act, (struct sigaction *) 0);
#ifdef SIGQUIT
    sigaction (SIGQUIT, &sig_act, (struct sigaction *) 0);
#endif
    sigaction (SIGILL, &sig_act, (struct sigaction *) 0);
#ifdef SIGBUS
    sigaction (SIGBUS, &sig_act, (struct sigaction *) 0);
#endif
    sigaction (SIGSEGV, &sig_act, (struct sigaction *) 0);
#ifdef SIGSYS
    sigaction (SIGSYS, &sig_act, (struct sigaction *) 0);
#endif
#endif /* USGISH */

    /*
     * now peruse through the list of files.
     */
    for (fp = filelist; *fp; fp++)
    {
        filecontent = getfile (*fp);
        ip = newinclude (*fp, (char *) NULL);

        find_includes (filecontent, ip, ip, 0, false);
        freefile (filecontent);
        recursive_pr_include (ip, ip->i_file, base_name (*fp));
        inc_clean ();
    }
    if (opt_printed)
        printf ("\n");
    return 0;
}