Return to output.c CVS log

Up to [Research Unix] / researchv9 / cmd / adb / sun

Annotation of researchv9/cmd/adb/sun/output.c, revision 1.1

1.1     ! root        1: #
        !             2: /*
        !             3:  *
        !             4:  *     UNIX debugger
        !             5:  *
        !             6:  */
        !             7: 
        !             8: #include "defs.h"
        !             9: 
        !            10: 
        !            11: int    infile = STDIN;
        !            12: int    outfile = STDOUT;
        !            13: int    maxpos = MAXPOS;
        !            14: int    radix = 0;      /* magic multi-radix */
        !            15: 
        !            16: static char    printbuf[MAXLIN];
        !            17: static char    *printptr = printbuf;
        !            18: static char    *digitptr;
        !            19: 
        !            20: printc(c)
        !            21: char           c;
        !            22: {
        !            23:        char    d;
        !            24:        register char   *q;
        !            25:        register int p;
        !            26:        int     posn, tabs;
        !            27: 
        !            28:        if (mkfault)
        !            29:                return;
        !            30:        else if ((*printptr=c)==EOR) {
        !            31:                tabs=0;
        !            32:                posn=0;
        !            33:                q=printbuf;
        !            34:                for (p=0; p<printptr-printbuf; p++) {
        !            35:                        d=printbuf[p];
        !            36:                        if ((p&7)==0 && posn) {
        !            37:                                tabs++;
        !            38:                                posn=0;
        !            39:                        }
        !            40:                        if (d==SPC)
        !            41:                                posn++;
        !            42:                        else {
        !            43:                                while (tabs>0) {
        !            44:                                        *q++=TB;
        !            45:                                        tabs--;
        !            46:                                }
        !            47:                                while (posn>0) {
        !            48:                                        *q++=SPC;
        !            49:                                        posn--;
        !            50:                                }
        !            51:                                *q++=d;
        !            52:                        }
        !            53:                }
        !            54:                *q++=EOR;
        !            55:                write(outfile,printbuf,q-printbuf);
        !            56:                printptr=printbuf;
        !            57:        } else if (c==TB) {
        !            58:                *printptr++=SPC;
        !            59:                while ((printptr-printbuf)&7)
        !            60:                        *printptr++=SPC;
        !            61:        } else if (c)
        !            62:                printptr++;
        !            63:        if (printptr >= &printbuf[MAXLIN-9]) {
        !            64:                write(outfile, printbuf, printptr - printbuf);
        !            65:                printptr = printbuf;
        !            66:        }
        !            67: }
        !            68: 
        !            69: charpos()
        !            70: {
        !            71:        return(printptr-printbuf);
        !            72: }
        !            73: 
        !            74: flushbuf()
        !            75: {
        !            76:        if (printptr!=printbuf)
        !            77:                printc(EOR);
        !            78: }
        !            79: 
        !            80: /*
        !            81:  * our very own printf.  yes.
        !            82:  * `int' things (like %d) expect ints
        !            83:  * `long' things (like %D) expect WORDs
        !            84:  * there is no %f, for reasons to horrible to explain here
        !            85:  *
        !            86:  * declare lots of silly arguments because of the cray's calling sequence
        !            87:  */
        !            88: 
        !            89: printf(fmat, a1, a2, a3, a4, a5, a6, a7, a8, a9)
        !            90: char *fmat;
        !            91: int a1;
        !            92: {
        !            93:        register int *ap;
        !            94:        register char *s;
        !            95:        register int n, width;
        !            96:        int prec;
        !            97:        char *fptr;
        !            98:        int *ip;
        !            99:        WORD *lp;
        !           100:        char **sp;
        !           101:        char c, adj;
        !           102:        char digits[64];
        !           103: 
        !           104:        fptr = fmat;
        !           105:        ap = &a1;               /* hack */
        !           106:        while (c = *fptr++) {
        !           107:                if (c!='%') {
        !           108:                        printc(c);
        !           109:                        continue;
        !           110:                }
        !           111:                adj = 'r';
        !           112:                if (*fptr=='-') {
        !           113:                        adj = 'l';
        !           114:                        fptr++;
        !           115:                }
        !           116:                width=convert(&fptr);
        !           117:                prec = -1;
        !           118:                if (*fptr=='.') {
        !           119:                        fptr++;
        !           120:                        prec=convert(&fptr);
        !           121:                }
        !           122:                digitptr=digits;
        !           123:                s = NULL;
        !           124:                ip = (int *)ap;
        !           125:                lp = (long *)ap;
        !           126:                sp = (char **)ap;
        !           127:                switch (c = *fptr++) {
        !           128: 
        !           129:                case 'd':
        !           130:                        printsigned((WORD)*ip++, 10);
        !           131:                        ap = (int *)ip;
        !           132:                        break;
        !           133: 
        !           134:                case 'D':
        !           135:                        printsigned((WORD)*lp++, 10);
        !           136:                        ap = (int *)lp;
        !           137:                        break;
        !           138: 
        !           139:                case 'u':
        !           140:                        printus((WORD)*ip++, 10);
        !           141:                        ap = (int *)ip;
        !           142:                        break;
        !           143: 
        !           144:                case 'U':
        !           145:                        printus((WORD)*lp++, 10);
        !           146:                        ap = (int *)lp;
        !           147:                        break;
        !           148: 
        !           149:                case 'o':
        !           150:                        printus((WORD)*ip++, 8);
        !           151:                        ap = (int *)ip;
        !           152:                        break;
        !           153: 
        !           154:                case 'O':
        !           155:                        printus((WORD)*lp++, 8);
        !           156:                        ap = (int *)lp;
        !           157:                        break;
        !           158: 
        !           159:                case 'q':
        !           160:                        printsigned((WORD)*ip++, 8);
        !           161:                        ap = (int *)ip;
        !           162:                        break;
        !           163: 
        !           164:                case 'Q':
        !           165:                        printsigned((WORD)*lp++, 8);
        !           166:                        ap = (int *)lp;
        !           167:                        break;
        !           168: 
        !           169:                case 'x':
        !           170:                        printus((WORD)*ip++, 16);
        !           171:                        ap = (int *)ip;
        !           172:                        break;
        !           173: 
        !           174:                case 'X':
        !           175:                        printus((WORD)*lp++, 16);
        !           176:                        ap = (int *)lp;
        !           177:                        break;
        !           178: 
        !           179:                case 'r':
        !           180:                        printmaybe((WORD)*ip++, radix == 0 ? DEFRADIX : radix);
        !           181:                        ap = (int *)ip;
        !           182:                        break;
        !           183: 
        !           184:                case 'R':
        !           185:                        printmaybe((WORD)*lp++, radix == 0 ? DEFRADIX : radix);
        !           186:                        ap = (int *)lp;
        !           187:                        break;
        !           188: 
        !           189:                case 'Y':
        !           190:                        printdate((long)*lp++);
        !           191:                        ap = (int *)lp;
        !           192:                        break;
        !           193: 
        !           194:                case 'c':
        !           195:                        printc((char)*ap++);
        !           196:                        break;
        !           197: 
        !           198:                case 's':
        !           199:                        s = *sp++;
        !           200:                        ap = (int *)sp;
        !           201:                        break;
        !           202: 
        !           203:                /* m is for `move' */
        !           204:                case 'm':
        !           205:                        break;
        !           206: 
        !           207:                case 'M':
        !           208:                        width = *ap++;
        !           209:                        break;
        !           210: 
        !           211:                case 'T':
        !           212:                        width = *ap++;
        !           213:                        /* fall in */
        !           214:                case 't':
        !           215:                        if (width)
        !           216:                                width -= charpos()%width;
        !           217:                        break;
        !           218: 
        !           219:                default:
        !           220:                        printc(c);
        !           221:                        break;
        !           222:                }
        !           223:                if (s == NULL) {
        !           224:                        *digitptr = 0;
        !           225:                        s = digits;
        !           226:                }
        !           227:                n = strlen(s);
        !           228:                if (prec >= 0 && prec < n)
        !           229:                        n = prec;
        !           230:                width -= n;
        !           231:                if (adj=='r')
        !           232:                        while (width-- > 0)
        !           233:                                printc(SPC);
        !           234:                while (n--)
        !           235:                        printc(*s++);
        !           236:                while (width-- > 0)
        !           237:                        printc(SPC);
        !           238:                digitptr=digits;
        !           239:        }
        !           240: }
        !           241: 
        !           242: printdate(tvec)
        !           243: long tvec;
        !           244: {
        !           245:        char *ctime();
        !           246: 
        !           247:        strcpy(digitptr, ctime(&tvec));
        !           248:        digitptr += strlen(digitptr) - 1;       /* chop the newline */
        !           249: }
        !           250: 
        !           251: prints(s)
        !           252: char *s;
        !           253: {
        !           254:        printf("%s",s);
        !           255: }
        !           256: 
        !           257: newline()
        !           258: {
        !           259:        printc(EOR);
        !           260: }
        !           261: 
        !           262: convert(cp)
        !           263: register char **cp;
        !           264: {
        !           265:        register char c;
        !           266:        register int n;
        !           267: 
        !           268:        n=0;
        !           269:        while (isdigit(c = *(*cp)++))
        !           270:                n=n*10+c-'0';
        !           271:        (*cp)--;
        !           272:        return(n);
        !           273: }
        !           274: 
        !           275: printmaybe(n, base)
        !           276: WORD n;
        !           277: {
        !           278:        if (REALLYNEG(n))
        !           279:                printsigned(n, 10);
        !           280:        else
        !           281:                printus(n, base);
        !           282: }
        !           283: 
        !           284: printsigned(n, base)
        !           285: WORD n;
        !           286: int base;
        !           287: {
        !           288: 
        !           289:        if (n < 0) {
        !           290:                n = -n;
        !           291:                /* if (n < 0)  what? */
        !           292:                *digitptr++ = '-';
        !           293:        }
        !           294:        printnum((unsigned long)n, base);
        !           295: }
        !           296: 
        !           297: printus(n, base)
        !           298: WORD n;
        !           299: int base;
        !           300: {
        !           301: 
        !           302:        printnum((unsigned long)n, base);
        !           303: }
        !           304: 
        !           305: printnum(n, base)
        !           306: unsigned long n;
        !           307: int base;
        !           308: {
        !           309:        unsigned long d;
        !           310:        register int r;
        !           311:        static char digits[] = "0123456789abcdef";
        !           312: 
        !           313:        if ((d = n / base) != 0) {
        !           314:                printnum(d, base);
        !           315:                r = n - (d * base);
        !           316:        }
        !           317:        else {                  /* hack for first digit */
        !           318:                r = n;
        !           319:                if (base == radix) {
        !           320:                        if (r >= 10)
        !           321:                                *digitptr++ = '0';
        !           322:                }
        !           323:                else if (radix == 0)
        !           324:                        switch (base) {
        !           325:                        case 16:
        !           326:                                *digitptr++ = '0';
        !           327:                                *digitptr++ = 'x';
        !           328:                                break;
        !           329: 
        !           330:                        case 8:
        !           331:                                if (r)
        !           332:                                        *digitptr++ = '0';
        !           333:                                break;
        !           334:                        }
        !           335:        }
        !           336:        if (r < sizeof(digits) - 1)
        !           337:                *digitptr++ = digits[r];
        !           338:        else
        !           339:                *digitptr++ = '?';
        !           340: }
        !           341: 
        !           342: #define        MAXIFD  5
        !           343: struct {
        !           344:        int     fd;
        !           345:        int     r9;
        !           346: } istack[MAXIFD];
        !           347: int    ifiledepth;
        !           348: 
        !           349: iclose(stack, err)
        !           350: {
        !           351:        if (err) {
        !           352:                if (infile) {
        !           353:                        close(infile);
        !           354:                        infile=STDIN;
        !           355:                }
        !           356:                while (--ifiledepth >= 0)
        !           357:                        if (istack[ifiledepth].fd)
        !           358:                                close(istack[ifiledepth].fd);
        !           359:                ifiledepth = 0;
        !           360:        } else if (stack == 0) {
        !           361:                if (infile) {
        !           362:                        close(infile);
        !           363:                        infile=STDIN;
        !           364:                }
        !           365:        } else if (stack > 0) {
        !           366:                if (ifiledepth >= MAXIFD)
        !           367:                        error("$<< nested too deeply");
        !           368:                istack[ifiledepth].fd = infile;
        !           369:                istack[ifiledepth].r9 = var[9];
        !           370:                ifiledepth++;
        !           371:                infile = STDIN;
        !           372:        } else {
        !           373:                if (infile) {
        !           374:                        close(infile); 
        !           375:                        infile=STDIN;
        !           376:                }
        !           377:                if (ifiledepth > 0) {
        !           378:                        infile = istack[--ifiledepth].fd;
        !           379:                        var[9] = istack[ifiledepth].r9;
        !           380:                }
        !           381:        }
        !           382: }
        !           383: 
        !           384: oclose()
        !           385: {
        !           386:        if (outfile!=1) {
        !           387:                flushbuf();
        !           388:                close(outfile);
        !           389:                outfile=STDOUT;
        !           390:        }
        !           391: }
        !           392: 
        !           393: endline()
        !           394: {
        !           395: 
        !           396:        if (maxpos <= charpos())
        !           397:                newline();
        !           398: }

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