Return to ref.c CVS log

Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis

Annotation of coherent/d/usr/bin/elvis/ref.c, revision 1.1

1.1     ! root        1: /* ref.c */
        !             2: 
        !             3: /* Author:
        !             4:  *     Steve Kirkendall
        !             5:  *     16820 SW Tallac Way
        !             6:  *     Beaverton, OR 97006
        !             7:  *     [email protected], or ...uunet!tektronix!psueea!jove!kirkenda
        !             8:  */
        !             9: 
        !            10: 
        !            11: /* This program looks up the declarations of library functions. */
        !            12: 
        !            13: #include <stdio.h>
        !            14: 
        !            15: /* This is the list of files that are searched. */
        !            16: #ifdef OSK
        !            17: char *refslist[] = {
        !            18:        "refs",
        !            19:        "/dd/usr/src/lib/refs",
        !            20:        "../lib/refs",
        !            21:        "/dd/usr/local/lib/refs",
        !            22: };
        !            23: #else
        !            24: char *refslist[] = {
        !            25:        "refs",
        !            26:        "/usr/src/lib/refs",
        !            27:        "../lib/refs",
        !            28:        "/usr/local/lib/refs",
        !            29: };
        !            30: #endif
        !            31: #define NREFS  (sizeof refslist / sizeof(char *))
        !            32: 
        !            33: main(argc, argv)
        !            34:        int     argc;
        !            35:        char    **argv;
        !            36: {
        !            37:        int     i;      /* used to step through the refslist */
        !            38: 
        !            39:        /* make sure our arguments are OK */
        !            40:        if (argc != 2)
        !            41:        {
        !            42:                fprintf(stderr, "usage: %s function_name\n", *argv);
        !            43:                exit(2);
        !            44:        }
        !            45: 
        !            46:        /* check for the function in each database */
        !            47:        for (i = 0; i < NREFS; i++)
        !            48:        {
        !            49:                if (lookinfor(refslist[i], argv[1]))
        !            50:                {
        !            51:                        exit(0);
        !            52:                }
        !            53:        }
        !            54: 
        !            55:        fprintf(stderr, "%s: don't know about %s\n", argv[0], argv[1]);
        !            56:        exit(2);
        !            57: }
        !            58: 
        !            59: 
        !            60: /* This function checks a single file for the function.  Returns 1 if found */
        !            61: int lookinfor(filename, func)
        !            62:        char    *filename;      /* name of file to look in */
        !            63:        char    *func;          /* name of function to look for */
        !            64: {
        !            65:        FILE    *fp;    /* stream used to access the database */
        !            66:        char    linebuf[300];
        !            67:                /* NOTE: in actual use, the first character of linebuf is */
        !            68:                /* set to ' ' and then we use all EXCEPT the 1st character */
        !            69:                /* everywhere in this function.  This is because the func */
        !            70:                /* which examines the linebuf could, in some circumstances */
        !            71:                /* examine the character before the used part of linebuf; */
        !            72:                /* we need to control what happens then.                   */
        !            73: 
        !            74: 
        !            75:        /* open the database file */
        !            76:        fp = fopen(filename, "r");
        !            77:        if (!fp)
        !            78:        {
        !            79:                return 0;
        !            80:        }
        !            81: 
        !            82:        /* find the desired entry */
        !            83:        *linebuf = ' ';
        !            84:        do
        !            85:        {
        !            86:                if (!fgets(linebuf + 1, (sizeof linebuf) - 1, fp))
        !            87:                {
        !            88:                        fclose(fp);
        !            89:                        return 0;
        !            90:                }
        !            91:        } while (!desired(linebuf + 1, func));
        !            92: 
        !            93:        /* print it */
        !            94:        do
        !            95:        {
        !            96:                fputs(linebuf + 1, stdout);
        !            97:        } while (fgets(linebuf + 1, sizeof linebuf, fp) && linebuf[1] == '\t');
        !            98: 
        !            99:        /* cleanup & exit */
        !           100:        fclose(fp);
        !           101:        return 1;
        !           102: }
        !           103: 
        !           104: 
        !           105: /* This function checks to see if a given line is the first line of the */
        !           106: /* entry the user wants to see.  If it is, return non-0 else return 0   */
        !           107: desired(line, word)
        !           108:        char    *line;  /* the line buffer */
        !           109:        char    *word;  /* the string it should contain */
        !           110: {
        !           111:        static  wlen = -1;/* length of the "word" variable's value */
        !           112:        register char *scan;
        !           113: 
        !           114:        /* if this line starts with a tab, it couldn't be desired */
        !           115:        if (*line == '\t')
        !           116:        {
        !           117:                return 0;
        !           118:        }
        !           119: 
        !           120:        /* if we haven't found word's length yet, do so */
        !           121:        if (wlen < 0)
        !           122:        {
        !           123:                wlen = strlen(word);
        !           124:        }
        !           125: 
        !           126:        /* search for the word in the line */
        !           127:        for (scan = line; *scan != '('; scan++)
        !           128:        {
        !           129:        }
        !           130:        while (*--scan == ' ')
        !           131:        {
        !           132:        }
        !           133:        scan -= wlen;
        !           134:        if (scan < line - 1 || *scan != ' ' && *scan != '\t' && *scan != '*')
        !           135:        {
        !           136:                return 0;
        !           137:        }
        !           138:        scan++;
        !           139:        return !strncmp(scan, word, wlen);
        !           140: }

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