Return to input.c CVS log

Up to [Research Unix] / researchv10no / cmd / lcc / c

Annotation of researchv10no/cmd/lcc/c/input.c, revision 1.1

1.1     ! root        1: /* C compiler: input processing */
        !             2: 
        !             3: #include "c.h"
        !             4: 
        !             5: unsigned char *cp;     /* current input character */
        !             6: char *file;            /* current input file name */
        !             7: char *firstfile;       /* first input file */
        !             8: unsigned char *limit;  /* points to last character + 1 */
        !             9: char *line;            /* current line */
        !            10: int lineno;            /* line number of current line */
        !            11: 
        !            12: static int infd;       /* input file descriptor */
        !            13: static int bsize;      /* number of chars in last read */
        !            14: static unsigned char buffer[MAXLINE+1 + BUFSIZE+1];    /* input buffer */
        !            15: 
        !            16: dclproto(static void pragma,(void));
        !            17: dclproto(static void resynch,(void));
        !            18: 
        !            19: /* inputInit - initialize input processing */
        !            20: void inputInit(fd) {
        !            21:        limit = cp = &buffer[MAXLINE + 1];
        !            22:        lineno = 0;
        !            23:        file = 0;                       /* omit */
        !            24:        bsize = -1;
        !            25:        infd = fd;
        !            26:        nextline();
        !            27: }
        !            28: 
        !            29: /* inputstring - arrange to read str as next input */
        !            30: void inputstring(str) char *str; {
        !            31:        limit = cp = &buffer[MAXLINE+1];
        !            32:        while (*limit++ = *str++)
        !            33:                ;
        !            34:        *limit = '\n';
        !            35:        bsize = 0;
        !            36: }
        !            37: 
        !            38: /* fillbuf - fill the input buffer, moving tail portion if necessary */
        !            39: void fillbuf() {
        !            40:        if (bsize == 0)
        !            41:                return;
        !            42:        if (limit <= cp)
        !            43:                cp = &buffer[MAXLINE + 1];
        !            44:        else {          /* move tail portion */
        !            45:                int n = limit - cp;
        !            46:                unsigned char *s = &buffer[MAXLINE + 1] - n;
        !            47:                assert(s >= buffer);
        !            48:                line = (char *)s - ((char *)cp - line);
        !            49:                while (cp < limit)
        !            50:                        *s++ = *cp++;
        !            51:                cp = &buffer[MAXLINE + 1] - n;
        !            52:        }
        !            53:        bsize = read(infd, (char *)&buffer[MAXLINE + 1], BUFSIZE);
        !            54:        assert(bsize >= 0);
        !            55:        limit = &buffer[MAXLINE + 1 + bsize];
        !            56:        *limit = '\n';
        !            57: }
        !            58: 
        !            59: /* nextline - prepare to read next line */
        !            60: void nextline() {
        !            61:        if (cp >= limit) {      /* refill buffer */
        !            62:                fillbuf();
        !            63:                if (cp >= limit) {      /* signal end of file */
        !            64:                        cp = limit = &buffer[MAXLINE+1];
        !            65:                        *limit = '\0';
        !            66:                }
        !            67:                if (lineno > 0)
        !            68:                        return;
        !            69:        }
        !            70:        lineno++;
        !            71:        for (line = (char *)cp; *cp == ' ' || *cp == '\t'; cp++)
        !            72:                ;
        !            73:        if (*cp == '#') {                       /* omit */
        !            74:                resynch();                      /* omit */
        !            75:                nextline();                     /* omit */
        !            76:        }                                       /* omit */
        !            77: }
        !            78: 
        !            79: /* pragma - handle #pragma ref id... */
        !            80: static void pragma() {
        !            81:        if ((t = gettok()) == ID && strcmp(token, "ref") == 0)
        !            82:                for (;;) {
        !            83:                        while (*cp == ' ' || *cp == '\t')
        !            84:                                cp++;
        !            85:                        if (*cp == '\n' || *cp == 0)
        !            86:                                break;
        !            87:                        if ((t = gettok()) == ID && tsym) {
        !            88:                                tsym->ref++;
        !            89:                                use(tsym, src);
        !            90:                        }       
        !            91:                }
        !            92: }
        !            93: 
        !            94: /* resynch - set line number/file name in # n [ "file" ] and #pragma ... */
        !            95: static void resynch() {
        !            96:        for (cp++; *cp == ' ' || *cp == '\t'; )
        !            97:                cp++;
        !            98:        if (limit - cp < MAXLINE)
        !            99:                fillbuf();
        !           100:        if (strncmp((char *)cp, "pragma", 6) == 0) {
        !           101:                cp += 6;
        !           102:                pragma();
        !           103:        } else if (*cp >= '0' && *cp <= '9') {
        !           104:        line:   for (lineno = 0; *cp >= '0' && *cp <= '9'; )
        !           105:                        lineno = 10*lineno + *cp++ - '0';
        !           106:                lineno--;
        !           107:                while (*cp == ' ' || *cp == '\t')
        !           108:                        cp++;
        !           109:                if (*cp == '"') {
        !           110:                        file = (char *)++cp;
        !           111:                        while (*cp && *cp != '"' && *cp != '\n')
        !           112:                                cp++;
        !           113:                        file = stringn(file, (char *)cp - file);
        !           114:                        if (*cp == '\n')
        !           115:                                warning("missing \" in preprocessor line\n");
        !           116:                        if (firstfile == 0)
        !           117:                                firstfile = file;
        !           118:                }
        !           119:        } else if (strncmp((char *)cp, "line", 4) == 0) {
        !           120:                for (cp += 4; *cp == ' ' || *cp == '\t'; )
        !           121:                        cp++;
        !           122:                if (*cp >= '0' && *cp <= '9')
        !           123:                        goto line;
        !           124:                if (Aflag >= 2)
        !           125:                        warning("unrecognized control line\n");
        !           126:        } else if (Aflag >= 2 && *cp != '\n')
        !           127:                warning("unrecognized control line\n");
        !           128:        while (*cp)
        !           129:                if (*cp++ == '\n')
        !           130:                        if (cp == limit + 1)
        !           131:                                nextline();
        !           132:                        else
        !           133:                                break;
        !           134: }

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