Annotation of researchv10dc/cmd/pret/pret8.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include "pret.h"
        !             3: 
        !             4: struct {
        !             5:        char name[MAXNAME];
        !             6:        int status;
        !             7:        int initval;
        !             8:        int index;      /* set if used as array */
        !             9:        int width;      /* in bits: for supertrace */
        !            10: } vartbl[MANY];
        !            11: 
        !            12: struct {
        !            13:        int m;          /* index of basename in vartbl */
        !            14:        int n;          /* reference to the index      */
        !            15: } ivartbl[MANY];
        !            16: int realnrvars=0;
        !            17: 
        !            18: struct {
        !            19:        int m;          /* index of basename in globvartbl */
        !            20:        int n;          /* reference to the index      */
        !            21: } igvartbl[MANY];
        !            22: int realgvars=0;
        !            23: 
        !            24: struct {
        !            25:        char name[MAXNAME];
        !            26:        int status;
        !            27:        int initval;
        !            28:        int index;
        !            29:        int width;
        !            30: } globvartbl[MANY];
        !            31: 
        !            32: int nrvars = 0;
        !            33: int nrglobvars = 0;
        !            34: int varwidths = 0;
        !            35: 
        !            36: extern char procname[MAXNAME];
        !            37: extern char refname[MAXNAME];
        !            38: extern int anyerror, pid, rid;
        !            39: 
        !            40: reallocal(m, n)
        !            41: {      int i;
        !            42:        for (i = 0; i < realnrvars; i++)
        !            43:                if (ivartbl[i].m == m && ivartbl[i].n == n)
        !            44:                        return i;
        !            45:        if ((i = realnrvars++) >= MANY)
        !            46:                whoops("reallocal overflow");
        !            47:        ivartbl[i].n = n;
        !            48:        ivartbl[i].m = m;
        !            49:        return i;
        !            50: }
        !            51: 
        !            52: realglobal(m, n)
        !            53: {      int i;
        !            54:        for (i = 0; i < realgvars; i++)
        !            55:                if (igvartbl[i].m == m && igvartbl[i].n == n)
        !            56:                        return i;
        !            57:        if ((i = realgvars++) >= MANY)
        !            58:                whoops("realglobal overflow");
        !            59:        igvartbl[i].n = n;
        !            60:        igvartbl[i].m = m;
        !            61:        return i;
        !            62: }
        !            63: 
        !            64: twiddle(suff)
        !            65:        char *suff;
        !            66: {      int i; extern int extras;
        !            67: 
        !            68:        for (i = 0; i < nrvars; i++)
        !            69:                if (strcmp(vartbl[i].name, suff) == 0)
        !            70:                {       vartbl[i].initval++;
        !            71:                        return;
        !            72:                }
        !            73:        whoops("cannot happen, twiddle");
        !            74: }
        !            75: 
        !            76: isarrayvar(suff)
        !            77:        char *suff;
        !            78: {      int i;
        !            79: 
        !            80:        for (i = 0; i < nrvars; i++)
        !            81:                if (strcmp(vartbl[i].name, suff) == 0
        !            82:                && vartbl[i].index != NONE)
        !            83:                        return 1;
        !            84:        for (i = 0; i < nrglobvars; i++)
        !            85:                if (strcmp(globvartbl[i].name, suff) == 0
        !            86:                && globvartbl[i].index != NONE)
        !            87:                        return 1;
        !            88:        return 0;
        !            89: }
        !            90: 
        !            91: looklocal(suff, how, index)
        !            92:        char *suff;
        !            93: {      int i;
        !            94: 
        !            95:        for (i = 0; i < nrvars; i++)
        !            96:                if (strcmp(vartbl[i].name, suff) == 0)
        !            97:                {       vartbl[i].status |= how;
        !            98:                        break;
        !            99:                }
        !           100: 
        !           101:        if (i != nrvars && how == DCL)
        !           102:                yyerror("local variable redeclared, %s", suff);
        !           103: 
        !           104:        if (i != nrvars && how == RFR && index != vartbl[i].index
        !           105:        && (index == NONE || vartbl[i].index == NONE))
        !           106:                yyerror("local variable array indexing error, %s", suff);
        !           107:        return i;
        !           108: }
        !           109: 
        !           110: lookglobal(suff, how, index)
        !           111:        char *suff;
        !           112: {      int i;
        !           113: 
        !           114:        for (i = 0; i < nrglobvars; i++)
        !           115:                if (strcmp(globvartbl[i].name, suff) == 0)
        !           116:                {       globvartbl[i].status |= how;
        !           117:                        break;
        !           118:                }
        !           119: 
        !           120:        if (pid == NONE && rid == NONE && i != nrglobvars && how == DCL)
        !           121:                yyerror("global variable redeclared, %s", suff);
        !           122: 
        !           123:        if (i != nrglobvars && how == RFR && index != globvartbl[i].index
        !           124:        && (index == NONE || globvartbl[i].index == NONE))
        !           125:                yyerror("global variable array indexing error, %s", suff);
        !           126:        return i;
        !           127: }
        !           128: 
        !           129: putlocal(what, ival, how, index, width)
        !           130:        char *what;
        !           131: {      int i;
        !           132: 
        !           133:        if ((i = nrvars++) >= MANY)
        !           134:                whoops("too many variables");
        !           135: 
        !           136:        strcpy(vartbl[i].name, what);
        !           137:        vartbl[i].initval = ival;
        !           138:        vartbl[i].status = how;
        !           139:        vartbl[i].index = index;
        !           140:        vartbl[i].width = width;
        !           141:        if (index != NONE && ival != NONE)
        !           142:        {       fprintf(stderr,"error: no automatic initialization");
        !           143:                fprintf(stderr, " of array `%s'\n",what);
        !           144:                anyerror++;
        !           145:        }
        !           146:        if (width != 0) varwidths=1;
        !           147:        return (MANY + i);
        !           148: }
        !           149: 
        !           150: putglobal(what, ival, how, index, width)
        !           151:        char *what;
        !           152: {      int i;
        !           153: 
        !           154:        if ((i = nrglobvars++) >= MANY)
        !           155:                whoops("too many variables");
        !           156:        strcpy(globvartbl[i].name, what);
        !           157:        globvartbl[i].initval = ival;
        !           158:        globvartbl[i].status = how;
        !           159:        globvartbl[i].index = index;
        !           160:        globvartbl[i].width = width;
        !           161:        if (index != NONE && ival != NONE)
        !           162:        {       fprintf(stderr,"error: no automatic initialization");
        !           163:                fprintf(stderr, " of array `%s'\n",what);
        !           164:                anyerror++;
        !           165:        }
        !           166:        if (width != 0) varwidths=1;
        !           167: 
        !           168:        return i;
        !           169: }
        !           170: /*
        !           171:  * arrays are merely patched in for now
        !           172:  */
        !           173: addvarname(what, how, ival, index, width)
        !           174:        char *what;
        !           175: {
        !           176:        int i, islocal = (rid != NONE || pid != NONE);
        !           177: 
        !           178:        if (rid != NONE && (i = Fparname(what, rid, ISV, NONE, how, index)) != -1)
        !           179:                return (2*MANY + i);
        !           180:        /* formal parameter may not be an array reference */
        !           181: 
        !           182:        if (islocal && (i = looklocal(what, how, index)) < nrvars)
        !           183:                return (MANY + reallocal(i, index));
        !           184:        if ((i = lookglobal(what, how, index)) < nrglobvars)
        !           185:                return realglobal(i, index);
        !           186: 
        !           187:        if (how == RFR)
        !           188:                yyerror("undeclared variable, %s", what);
        !           189:        if (islocal)
        !           190:                return putlocal(what, ival, how, index, width);
        !           191: 
        !           192:        return putglobal(what, ival, how, index, width);
        !           193: }
        !           194: 
        !           195: checklocvars()
        !           196: {      int i;
        !           197: 
        !           198:        for (i = 0; i < nrvars; i++)
        !           199:                if (vartbl[i].status == DCL)
        !           200:                {       printf("%s: ", (pid != NONE)?procname:refname);
        !           201:                        printf("pvar %s is never used\n", vartbl[i].name);
        !           202:                }
        !           203: }
        !           204: 
        !           205: checkglobvars()
        !           206: {      int i;
        !           207: 
        !           208:        for (i = 0; i < nrglobvars; i++)
        !           209:                if (globvartbl[i].status == DCL)
        !           210:                {       printf("global: ");
        !           211:                        printf("pvar %s is never used\n", globvartbl[i].name);
        !           212:                }
        !           213: }
        !           214: 
        !           215: numglobvars(fd)
        !           216:        FILE *fd;
        !           217: {      int i;
        !           218: 
        !           219:        fprintf(fd, "%d g-variables: ", nrglobvars);
        !           220:        for (i = 0; i < nrglobvars; i++)
        !           221:                fprintf(fd, "%d/%d,", globvartbl[i].initval, globvartbl[i].index);
        !           222:        putc('\n', fd);
        !           223:        if (varwidths)
        !           224:        {       fprintf(fd, "%d g-widths: ", nrglobvars);
        !           225:                for (i = 0; i < nrglobvars; i++)
        !           226:                        fprintf(fd, "%d,", globvartbl[i].width);
        !           227:                putc('\n', fd);
        !           228:        }
        !           229:        fprintf(fd, "%d g-uses: ", realgvars);
        !           230:        for (i = 0; i < realgvars; i++)
        !           231:                fprintf(fd, "%d/%d,", igvartbl[i].m, igvartbl[i].n);            
        !           232:        putc('\n', fd);
        !           233: }
        !           234: 
        !           235: numlocvars(fd)
        !           236:        FILE *fd;
        !           237: {      int i;
        !           238: 
        !           239:        fprintf(fd, "%d l-variables: ", nrvars);
        !           240:        for (i = 0; i < nrvars; i++)
        !           241:                fprintf(fd, "%d/%d,", vartbl[i].initval, vartbl[i].index);
        !           242:        putc('\n', fd);
        !           243:        if (varwidths)
        !           244:        {       fprintf(fd, "%d l-widths: ", nrvars);
        !           245:                for (i = 0; i < nrvars; i++)
        !           246:                        fprintf(fd, "%d,", vartbl[i].width);
        !           247:                putc('\n', fd);
        !           248:        }
        !           249: 
        !           250:        fprintf(fd, "%d l-uses: ", realnrvars);
        !           251:        for (i = 0; i < realnrvars; i++)
        !           252:                fprintf(fd, "%d/%d,", ivartbl[i].m, ivartbl[i].n);              
        !           253:        putc('\n', fd);
        !           254: }

unix.superglobalmegacorp.com

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