Return to pr.c CVS log

Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / util / makedepend

Annotation of researchv9/X11/src/X.V11R1/util/makedepend/pr.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * $Header: pr.c,v 1.2 87/08/14 18:08:47 toddb Exp $
        !             3:  *
        !             4:  * $Log:       pr.c,v $
        !             5:  * Revision 1.2  87/08/14  18:08:47  toddb
        !             6:  * Don't unmark each included file in recursive_pr_includes(): leaving it
        !             7:  * marked prevents multiple inclusions from being printed if an include
        !             8:  * file happens to be a terminal node on the graph.
        !             9:  * 
        !            10:  * Revision 1.1  87/08/14  18:01:02  toddb
        !            11:  * Initial revision
        !            12:  * 
        !            13:  * Revision 1.1  87/04/08  16:40:57  rich
        !            14:  * Initial revision
        !            15:  * 
        !            16:  * Revision 1.2  86/04/18  14:06:52  toddb
        !            17:  * Added a new field to struct inclist: "i_marked".  This is used
        !            18:  * by recursive_pr() to tell if it is traversing a loop of include
        !            19:  * files.
        !            20:  * 
        !            21:  * Revision 1.1  86/04/15  08:34:45  toddb
        !            22:  * Initial revision
        !            23:  * 
        !            24:  */
        !            25: #include "def.h"
        !            26: 
        !            27: extern struct  inclist inclist[ MAXFILES ],
        !            28:                        *inclistp;
        !            29: extern char    *objfile;
        !            30: extern int     width;
        !            31: extern boolean printed;
        !            32: extern boolean verbose;
        !            33: extern boolean show_where_not;
        !            34: 
        !            35: add_include(file, file_red, include, dot)
        !            36:        struct inclist  *file, *file_red;
        !            37:        char    *include;
        !            38:        boolean dot;
        !            39: {
        !            40:        register struct inclist *newfile;
        !            41:        register struct filepointer     *content;
        !            42: 
        !            43:        /*
        !            44:         * First decide what the pathname of this include file really is.
        !            45:         */
        !            46:        newfile = inc_path(file->i_file, include, dot);
        !            47:        if (newfile == NULL) {
        !            48:                if (file != file_red)
        !            49:                        log("%s (reading %s): ",
        !            50:                                file_red->i_file, file->i_file);
        !            51:                else
        !            52:                        log("%s: ", file->i_file);
        !            53:                log("cannot find include file \"%s\"\n", include);
        !            54:                show_where_not = TRUE;
        !            55:                newfile = inc_path(file->i_file, include, dot);
        !            56:                show_where_not = FALSE;
        !            57:        }
        !            58: 
        !            59:        included_by(file, newfile);
        !            60:        if (!newfile->i_searched) {
        !            61:                newfile->i_searched = TRUE;
        !            62:                content = getfile(newfile->i_file);
        !            63:                find_includes(content, newfile, file_red, 0);
        !            64:                freefile(content);
        !            65:        }
        !            66: }
        !            67: 
        !            68: recursive_pr_include(head, file, base)
        !            69:        register struct inclist *head;
        !            70:        register char   *file, *base;
        !            71: {
        !            72:        register int    i;
        !            73: 
        !            74:        if (head->i_marked)
        !            75:                return;
        !            76:        head->i_marked = TRUE;
        !            77:        if (head->i_file != file)
        !            78:                pr(head, file, base);
        !            79:        for (i=0; i<head->i_listlen; i++)
        !            80:                recursive_pr_include(head->i_list[ i ], file, base);
        !            81: }
        !            82: 
        !            83: pr(ip, file, base)
        !            84:        register struct inclist  *ip;
        !            85:        char    *file, *base;
        !            86: {
        !            87:        static char     *lastfile;
        !            88:        static int      current_len;
        !            89:        register int    len, i;
        !            90:        char    buf[ BUFSIZ ];
        !            91: 
        !            92:        printed = TRUE;
        !            93:        len = strlen(ip->i_file)+1;
        !            94:        if (current_len + len > width || file != lastfile) {
        !            95:                lastfile = file;
        !            96:                sprintf(buf, "\n%s%s: %s", base, objfile, ip->i_file);
        !            97:                len = current_len = strlen(buf);
        !            98:        }
        !            99:        else {
        !           100:                buf[0] = ' ';
        !           101:                strcpy(buf+1, ip->i_file);
        !           102:                current_len += len;
        !           103:        }
        !           104:        fwrite(buf, len, 1, stdout);
        !           105: 
        !           106:        /*
        !           107:         * If verbose is set, then print out what this file includes.
        !           108:         */
        !           109:        if (! verbose || ip->i_list == NULL || ip->i_notified)
        !           110:                return;
        !           111:        ip->i_notified = TRUE;
        !           112:        lastfile = NULL;
        !           113:        printf("\n# %s includes:", ip->i_file);
        !           114:        for (i=0; i<ip->i_listlen; i++)
        !           115:                printf("\n#\t%s", ip->i_list[ i ]->i_incstring);
        !           116: }
        !           117: 
        !           118: catch(n)
        !           119: {
        !           120:        fflush(stdout);
        !           121:        log_fatal("got signal %d\n", n);
        !           122: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.