Return to sub.c CVS log

Up to [Research Unix] / researchv10no / cmd / sdb

Annotation of researchv10no/cmd/sdb/sub.c, revision 1.1

1.1     ! root        1: static char sccsid[] = "@(#)sub.c 4.1 10/9/80";
        !             2: #include "head.h"
        !             3: #include <a.out.h>
        !             4: #include <stab.h>
        !             5: #include "cdefs.h"
        !             6: #include <stdio.h>
        !             7: struct user u;
        !             8: 
        !             9: char *
        !            10: readline(f)
        !            11: FILE *f; {
        !            12:        static char buff[128];
        !            13:        
        !            14:        register char *p;
        !            15:        register int i;
        !            16:        
        !            17:        p = buff;
        !            18:        do {
        !            19:                if ((i = getc(f)) == EOF) {
        !            20:                        *p++ = '\004';
        !            21:                        *p = '\n';
        !            22:                        clearerr(f);
        !            23:                }
        !            24:                else *p = i;
        !            25:        } while (*p++ != '\n');
        !            26:        
        !            27:        return(buff);
        !            28: }
        !            29: 
        !            30: char *
        !            31: cpname(p, q)
        !            32: char *p, *q; {
        !            33:        while(varchar(*q) || number(*q))
        !            34:                *p++ = *q++;
        !            35:        *p = '\0';
        !            36:        return(q);
        !            37: }
        !            38: 
        !            39: char *
        !            40: cpall(p, q)
        !            41: char *p, *q; {
        !            42:        while (*q != '\n') 
        !            43:                *p++ = *q++;
        !            44:        *p = '\0';
        !            45:        return(q);
        !            46: }
        !            47: 
        !            48: eqany(c, s)
        !            49: char c, *s; {
        !            50:        while(*s != '\0')
        !            51:                if (c == *s++) return(1);
        !            52:        return(0);
        !            53: }
        !            54: 
        !            55: error(s)
        !            56: char *s; {
        !            57:        printf("%s\n", s);
        !            58: }
        !            59: 
        !            60: char *
        !            61: cpstr(p,q)
        !            62: char *p, *q; {
        !            63:        do {
        !            64:                *p++ = *q++;
        !            65:        } while (*q != '\0');
        !            66:        *p = '\0';
        !            67: }
        !            68: L_INT
        !            69: round(a,b)
        !            70: REG L_INT a, b;
        !            71: {
        !            72:        REG L_INT w;
        !            73:        w = (a/b)*b;
        !            74:        IF a!=w THEN w += b; FI
        !            75:        return(w);
        !            76: }
        !            77: 
        !            78: /* error handling */
        !            79: 
        !            80: chkerr()
        !            81: {
        !            82:        IF errflg ORF mkfault
        !            83:        THEN    error(errflg);
        !            84:                longjmp(env, 0);
        !            85:        FI
        !            86: }
        !            87: 
        !            88: eqstr(s1, s2)
        !            89:        REG STRING      s1, s2;
        !            90: {
        !            91: #ifndef FLEXNAMES
        !            92:        REG STRING       es1;
        !            93: #endif
        !            94:        if (s2 == (STRING) -1) return(0);
        !            95: #ifndef FLEXNAMES
        !            96:        es1 = s1+8;
        !            97: #endif
        !            98:        WHILE *s1++ == *s2
        !            99: #ifndef FLEXNAMES
        !           100:        DO IF *s2++ == 0 ORF s1>=es1
        !           101: #else
        !           102:        DO IF *s2++ == 0
        !           103: #endif
        !           104:           THEN return(1);
        !           105:           FI
        !           106:        OD
        !           107:        return(0);
        !           108: }
        !           109: 
        !           110: longseek(f, a)
        !           111: L_INT a;
        !           112: {
        !           113:        return(lseek(f,(long) a,0) != -1);
        !           114: }
        !           115: 
        !           116: 
        !           117: /* descriptor format to length */
        !           118: dtol(d)
        !           119: char d; {
        !           120:        switch(d) {
        !           121:        
        !           122:        case 'a':
        !           123:        case 's':
        !           124:                return(0);
        !           125:                
        !           126:        case 'b':
        !           127:        case 'c':
        !           128:                return(1);
        !           129:                
        !           130:        case 'h':
        !           131:                return(2);
        !           132:                
        !           133:        case 'l':
        !           134:        case 'f':
        !           135:                return(4);
        !           136: 
        !           137:        case 'g':
        !           138:                return(8);
        !           139: 
        !           140:        default:
        !           141:                return(WORDSIZE);
        !           142:        }
        !           143: }
        !           144: 
        !           145: /*
        !           146:  * checks equality of pattern pat with str,
        !           147:  * assuming str is tructaed at length 8
        !           148:  */
        !           149: eqpat(pat, str)
        !           150: char *pat, *str; {
        !           151: #ifndef FLEXNAMES
        !           152:        return(eqpatr(pat, str, 0));
        !           153: #else
        !           154:        return(eqpatr(pat, str));
        !           155: #endif
        !           156: }
        !           157: 
        !           158: #ifndef FLEXNAMES
        !           159: eqpatr(pat, str, cnt)
        !           160: #else
        !           161: eqpatr(pat, str)
        !           162: #endif
        !           163: char *pat, *str; {
        !           164:        register int i;
        !           165:        register char p, s;
        !           166:        
        !           167:        p = pat[0];
        !           168:        s = str[0];
        !           169: #ifndef FLEXNAMES
        !           170:        if (cnt == 8) return(1);
        !           171: #endif
        !           172:        if (p == '?') {
        !           173:                if (s == '\0') return(0);
        !           174: #ifndef FLEXNAMES
        !           175:                return(eqpatr(pat+1, str+1, cnt+1));
        !           176: #else
        !           177:                return(eqpatr(pat+1, str+1));
        !           178: #endif
        !           179:        }
        !           180:        if (p == '*') {
        !           181:                if (pat[1] == '\0') return(1);
        !           182: #ifndef FLEXNAMES
        !           183:                for(i=1; i<8-cnt; i++) {
        !           184:                        if (eqpatr(pat+1, str+i, cnt+i)) return(1);
        !           185: #else
        !           186:                for(i=1; ; i++) {
        !           187:                        if (eqpatr(pat+1, str+i)) return(1);
        !           188: #endif
        !           189:                        if (str[i] == '\0') return(0);
        !           190:                }
        !           191: #ifndef FLEXNAMES
        !           192:                return(0);
        !           193: #else
        !           194:                /*NOTREACHED*/
        !           195: #endif
        !           196:        }
        !           197:        if ((eqany(p, ".[->") || p == '\0') && s == '\0') return(1);
        !           198:        if (p != s) return(0);
        !           199: #ifndef FLEXNAMES
        !           200:        return(eqpatr(pat+1, str+1, cnt+1));
        !           201: #else
        !           202:        return(eqpatr(pat+1, str+1));
        !           203: #endif
        !           204: }
        !           205: 
        !           206: /* gets indirect address for pointers and subscripts */
        !           207: getindir(class, addr, type) 
        !           208: ADDR addr; {
        !           209:        if (ISARY(type)) return(addr);
        !           210:        if (class == N_RSYM)
        !           211:                return(*(ADDR *)(((ADDR) &u) + R0 + (WORDSIZE)*addr));
        !           212:        return(getval(addr, 'd', DSP));
        !           213: }
        !           214: 
        !           215: long
        !           216: readint(p)
        !           217: char **p; {
        !           218:        int sign;
        !           219: 
        !           220:        if (**p == '-') {
        !           221:                sign = -1;
        !           222:                (*p)++;
        !           223:        } else {
        !           224:                sign = 1;
        !           225:        }
        !           226:        if (**p == '0') {
        !           227:                (*p)++;
        !           228:                if (**p == 'x' || **p == 'X') {
        !           229:                        (*p)++;
        !           230:                        return(sign * rint(p, 16, hexdigit, hexconv));
        !           231:                }
        !           232:                else return(sign * rint(p, 8, octdigit, octconv));
        !           233:        }
        !           234:        else return(sign * rint(p, 10, decdigit, decconv));
        !           235: }
        !           236: 
        !           237: long
        !           238: rint(p, base, digit, conv)
        !           239: char **p;
        !           240: int (*digit)(), (*conv)(); {
        !           241:        long value;
        !           242:        
        !           243:        value = 0;
        !           244:        while ((*digit)(**p)) value = base*value + (*conv)(*(*p)++);  
        !           245:        return(value);
        !           246: }
        !           247: 
        !           248: octdigit(c) 
        !           249: char c; {
        !           250:        return(c >= '0' && c <= '7');
        !           251: }
        !           252: 
        !           253: octconv(c)
        !           254: char c; {
        !           255:        return(c - '0');
        !           256: }
        !           257: 
        !           258: decdigit(c)
        !           259: char c; {
        !           260:        return(c >= '0' && c <= '9');
        !           261: }
        !           262: 
        !           263: decconv(c)
        !           264: char c; {
        !           265:        return(c - '0');
        !           266: }
        !           267: 
        !           268: hexdigit(c)
        !           269: char c; {
        !           270:        return((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
        !           271:                (c >= 'A' && c <= 'F'));
        !           272: }
        !           273: 
        !           274: hexconv(c)
        !           275: char c; {
        !           276:        if (c >= '0' && c <= '9') return(c - '0');
        !           277:        if (c >= 'a' && c <= 'f') return(c - 'a' + 10);
        !           278:        if (c >= 'A' && c <= 'F') return(c - 'A' + 10);
        !           279:        error("hex conversion error");
        !           280:        return(0);
        !           281: }
        !           282: 
        !           283: /* decodes number, character or variable */
        !           284: long
        !           285: argvalue(p)
        !           286: char *p; {
        !           287:        register char ch;
        !           288:        register long value;
        !           289:        register ADDR j;
        !           290:        char var[30];
        !           291: 
        !           292:        ch = *p;
        !           293:        if (ch == '\'') {
        !           294:                value = *(p+1);
        !           295:        } else if ((ch >= '0' && ch <= '9') || ch == '-') {
        !           296:                value = readint(&p);
        !           297:        } else if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
        !           298:                ch == '_') {
        !           299:                cpname(var, p);
        !           300:                j = varaddr(curproc()->pname, var);
        !           301:                if (j == -1) {
        !           302:                        printf("Unknown variable: %s\n", argsp);
        !           303:                        return(-1);
        !           304:                }
        !           305:                value = getval(j, typetodesc(sl_type, 0)[0], DSP);
        !           306:                do {
        !           307:                        p++;
        !           308:                } while (varchar(*p) || number(*p));
        !           309:        }
        !           310:        return(value);
        !           311: }
        !           312: 
        !           313: prhex(v) 
        !           314: long v; {
        !           315:        if (v < 0)  {
        !           316:                v = -v;
        !           317:                printf("-");
        !           318:        }
        !           319:        if (v <= 9)
        !           320:                printf("%d", v);
        !           321:        else
        !           322:                printf("0x%x", v);
        !           323: }
        !           324: 
        !           325: /* print hex number in field of length 12 */
        !           326: prhex12(v) 
        !           327: long v; {
        !           328:        if (v >= -9 && v <= 9)
        !           329:                printf("%-12d", v);
        !           330:        else
        !           331:                printf("0x%-12x", v);
        !           332: }
        !           333: 
        !           334: /* print line number followed by offset */
        !           335: prlnoff(procp, v)
        !           336: struct proct *procp; ADDR v; {
        !           337:        int lineno, diff;
        !           338:        char *name;
        !           339:        name = procp->pname;
        !           340:        if (name[0] == '_') {
        !           341: #ifndef FLEXNAMES
        !           342:                printf("%.7s", name+1);
        !           343: #else
        !           344:                printf("%s", name+1);
        !           345: #endif
        !           346:                lineno = -1;
        !           347:        } else {
        !           348: #ifndef FLEXNAMES
        !           349:                printf("%8s", name);
        !           350: #else
        !           351:                printf("%s", name);
        !           352: #endif
        !           353:                lineno = adrtolineno((ADDR) v);
        !           354:        }
        !           355:        if (lineno == -1)
        !           356:                diff = v - procp->paddr;
        !           357:        else {
        !           358:                printf(":%d", lineno);
        !           359:                diff = v - lnfaddr;  /* set by adrtolineno() */
        !           360:        }
        !           361:        if (diff) {
        !           362:                printf("+");
        !           363:                prhex(diff);
        !           364:        }
        !           365: }

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