Return to parse.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / hexdump

Annotation of 43BSDReno/usr.bin/hexdump/parse.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1989 The Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms are permitted
        !             6:  * provided that: (1) source distributions retain this entire copyright
        !             7:  * notice and comment, and (2) distributions including binaries display
        !             8:  * the following acknowledgement:  ``This product includes software
        !             9:  * developed by the University of California, Berkeley and its contributors''
        !            10:  * in the documentation or other materials provided with the distribution
        !            11:  * and in all advertising materials mentioning features or use of this
        !            12:  * software. Neither the name of the University nor the names of its
        !            13:  * contributors may be used to endorse or promote products derived
        !            14:  * from this software without specific prior written permission.
        !            15:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
        !            16:  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
        !            17:  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        !            18:  */
        !            19: 
        !            20: #ifndef lint
        !            21: static char sccsid[] = "@(#)parse.c    5.4 (Berkeley) 6/1/90";
        !            22: #endif /* not lint */
        !            23: 
        !            24: #include <sys/types.h>
        !            25: #include <sys/file.h>
        !            26: #include <stdio.h>
        !            27: #include <ctype.h>
        !            28: #include <string.h>
        !            29: #include "hexdump.h"
        !            30: 
        !            31: FU *endfu;                                     /* format at end-of-data */
        !            32: 
        !            33: addfile(name)
        !            34:        char *name;
        !            35: {
        !            36:        register char *p;
        !            37:        FILE *fp;
        !            38:        int ch;
        !            39:        char buf[2048 + 1];
        !            40: 
        !            41:        if (!(fp = fopen(name, "r"))) {
        !            42:                (void)fprintf(stderr, "hexdump: can't read %s.\n", name);
        !            43:                exit(1);
        !            44:        }
        !            45:        while (fgets(buf, sizeof(buf), fp)) {
        !            46:                if (!(p = index(buf, '\n'))) {
        !            47:                        (void)fprintf(stderr, "hexdump: line too long.\n");
        !            48:                        while ((ch = getchar()) != '\n' && ch != EOF);
        !            49:                        continue;
        !            50:                }
        !            51:                *p = '\0';
        !            52:                for (p = buf; *p && isspace(*p); ++p);
        !            53:                if (!*p || *p == '#')
        !            54:                        continue;
        !            55:                add(p);
        !            56:        }
        !            57:        (void)fclose(fp);
        !            58: }
        !            59: 
        !            60: add(fmt)
        !            61:        char *fmt;
        !            62: {
        !            63:        register char *p;
        !            64:        static FS **nextfs;
        !            65:        FS *tfs;
        !            66:        FU *tfu, **nextfu;
        !            67:        char savech, *savep, *emalloc(), *strdup();
        !            68: 
        !            69:        /* start new linked list of format units */
        !            70:        /* NOSTRICT */
        !            71:        tfs = (FS *)emalloc(sizeof(FS));
        !            72:        if (!fshead)
        !            73:                fshead = tfs;
        !            74:        else
        !            75:                *nextfs = tfs;
        !            76:        nextfs = &tfs->nextfs;
        !            77:        nextfu = &tfs->nextfu;
        !            78: 
        !            79:        /* take the format string and break it up into format units */
        !            80:        for (p = fmt;;) {
        !            81:                /* skip leading white space */
        !            82:                for (; isspace(*p); ++p);
        !            83:                if (!*p)
        !            84:                        break;
        !            85: 
        !            86:                /* allocate a new format unit and link it in */
        !            87:                /* NOSTRICT */
        !            88:                tfu = (FU *)emalloc(sizeof(FU));
        !            89:                *nextfu = tfu;
        !            90:                nextfu = &tfu->nextfu;
        !            91:                tfu->reps = 1;
        !            92: 
        !            93:                /* if leading digit, repetition count */
        !            94:                if (isdigit(*p)) {
        !            95:                        for (savep = p; isdigit(*p); ++p);
        !            96:                        if (!isspace(*p) && *p != '/')
        !            97:                                badfmt(fmt);
        !            98:                        /* may overwrite either white space or slash */
        !            99:                        savech = *p;
        !           100:                        *p = '\0';
        !           101:                        tfu->reps = atoi(savep);
        !           102:                        tfu->flags = F_SETREP;
        !           103:                        *p = savech;
        !           104:                        /* skip trailing white space */
        !           105:                        for (++p; isspace(*p); ++p);
        !           106:                }
        !           107: 
        !           108:                /* skip slash and trailing white space */
        !           109:                if (*p == '/')
        !           110:                        while (isspace(*++p));
        !           111: 
        !           112:                /* byte count */
        !           113:                if (isdigit(*p)) {
        !           114:                        for (savep = p; isdigit(*p); ++p);
        !           115:                        if (!isspace(*p))
        !           116:                                badfmt(fmt);
        !           117:                        savech = *p;
        !           118:                        *p = '\0';
        !           119:                        tfu->bcnt = atoi(savep);
        !           120:                        *p = savech;
        !           121:                        /* skip trailing white space */
        !           122:                        for (++p; isspace(*p); ++p);
        !           123:                }
        !           124: 
        !           125:                /* format */
        !           126:                if (*p != '"')
        !           127:                        badfmt(fmt);
        !           128:                for (savep = ++p; *p != '"'; ++p);
        !           129:                if (*p != '"')
        !           130:                        badfmt(fmt);
        !           131:                savech = *p;
        !           132:                *p = '\0';
        !           133:                if (!(tfu->fmt = strdup(savep)))
        !           134:                        nomem();
        !           135:                escape(tfu->fmt);
        !           136:                *p++ = savech;
        !           137:        }
        !           138: }
        !           139: 
        !           140: static char *spec = ".#-+ 0123456789";
        !           141: size(fs)
        !           142:        FS *fs;
        !           143: {
        !           144:        register FU *fu;
        !           145:        register int bcnt, cursize;
        !           146:        register char *fmt;
        !           147:        int prec;
        !           148: 
        !           149:        /* figure out the data block size needed for each format unit */
        !           150:        for (cursize = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {
        !           151:                if (fu->bcnt) {
        !           152:                        cursize += fu->bcnt * fu->reps;
        !           153:                        continue;
        !           154:                }
        !           155:                for (bcnt = prec = 0, fmt = fu->fmt; *fmt; ++fmt) {
        !           156:                        if (*fmt != '%')
        !           157:                                continue;
        !           158:                        /*
        !           159:                         * skip any special chars -- save precision in
        !           160:                         * case it's a %s format.
        !           161:                         */
        !           162:                        while (index(spec + 1, *++fmt));
        !           163:                        if (*fmt == '.' && isdigit(*++fmt)) {
        !           164:                                prec = atoi(fmt);
        !           165:                                while (isdigit(*++fmt));
        !           166:                        }
        !           167:                        switch(*fmt) {
        !           168:                        case 'c':
        !           169:                                bcnt += 1;
        !           170:                                break;
        !           171:                        case 'd': case 'i': case 'o': case 'u':
        !           172:                        case 'x': case 'X':
        !           173:                                bcnt += 4;
        !           174:                                break;
        !           175:                        case 'e': case 'E': case 'f': case 'g': case 'G':
        !           176:                                bcnt += 8;
        !           177:                                break;
        !           178:                        case 's':
        !           179:                                bcnt += prec;
        !           180:                                break;
        !           181:                        case '_':
        !           182:                                switch(*++fmt) {
        !           183:                                case 'c': case 'p': case 'u':
        !           184:                                        bcnt += 1;
        !           185:                                        break;
        !           186:                                }
        !           187:                        }
        !           188:                }
        !           189:                cursize += bcnt * fu->reps;
        !           190:        }
        !           191:        return(cursize);
        !           192: }
        !           193: 
        !           194: rewrite(fs)
        !           195:        FS *fs;
        !           196: {
        !           197:        enum { NOTOKAY, USEBCNT, USEPREC } sokay;
        !           198:        register PR *pr, **nextpr;
        !           199:        register FU *fu;
        !           200:        register char *p1, *p2;
        !           201:        char savech, *fmtp;
        !           202:        int nconv, prec;
        !           203: 
        !           204:        for (fu = fs->nextfu; fu; fu = fu->nextfu) {
        !           205:                /*
        !           206:                 * break each format unit into print units; each
        !           207:                 * conversion character gets its own.
        !           208:                 */
        !           209:                for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) {
        !           210:                        /* NOSTRICT */
        !           211:                        pr = (PR *)emalloc(sizeof(PR));
        !           212:                        if (!fu->nextpr)
        !           213:                                fu->nextpr = pr;
        !           214:                        else
        !           215:                                *nextpr = pr;
        !           216: 
        !           217:                        /* skip preceding text and up to the next % sign */
        !           218:                        for (p1 = fmtp; *p1 && *p1 != '%'; ++p1);
        !           219: 
        !           220:                        /* only text in the string */
        !           221:                        if (!*p1) {
        !           222:                                pr->fmt = fmtp;
        !           223:                                pr->flags = F_TEXT;
        !           224:                                break;
        !           225:                        }
        !           226: 
        !           227:                        /*
        !           228:                         * get precision for %s -- if have a byte count, don't
        !           229:                         * need it.
        !           230:                         */
        !           231:                        if (fu->bcnt) {
        !           232:                                sokay = USEBCNT;
        !           233:                                /* skip to conversion character */
        !           234:                                for (++p1; index(spec, *p1); ++p1);
        !           235:                        } else {
        !           236:                                /* skip any special chars, field width */
        !           237:                                while (index(spec + 1, *++p1));
        !           238:                                if (*p1 == '.' && isdigit(*++p1)) {
        !           239:                                        sokay = USEPREC;
        !           240:                                        prec = atoi(p1);
        !           241:                                        while (isdigit(*++p1));
        !           242:                                }
        !           243:                                else
        !           244:                                        sokay = NOTOKAY;
        !           245:                        }
        !           246: 
        !           247:                        p2 = p1 + 1;            /* set end pointer */
        !           248: 
        !           249:                        /*
        !           250:                         * figure out the byte count for each conversion;
        !           251:                         * rewrite the format as necessary, set up blank-
        !           252:                         * padding for end of data.
        !           253:                         */
        !           254:                        switch(*p1) {
        !           255:                        case 'c':
        !           256:                                pr->flags = F_CHAR;
        !           257:                                switch(fu->bcnt) {
        !           258:                                case 0: case 1:
        !           259:                                        pr->bcnt = 1;
        !           260:                                        break;
        !           261:                                default:
        !           262:                                        p1[1] = '\0';
        !           263:                                        badcnt(p1);
        !           264:                                }
        !           265:                                break;
        !           266:                        case 'd': case 'i':
        !           267:                                pr->flags = F_INT;
        !           268:                                goto sw1;
        !           269:                        case 'l':
        !           270:                                ++p2;
        !           271:                                switch(p1[1]) {
        !           272:                                case 'd': case 'i':
        !           273:                                        ++p1;
        !           274:                                        pr->flags = F_INT;
        !           275:                                        goto sw1;
        !           276:                                case 'o': case 'u': case 'x': case 'X':
        !           277:                                        ++p1;
        !           278:                                        pr->flags = F_UINT;
        !           279:                                        goto sw1;
        !           280:                                default:
        !           281:                                        p1[2] = '\0';
        !           282:                                        badconv(p1);
        !           283:                                }
        !           284:                                /* NOTREACHED */
        !           285:                        case 'o': case 'u': case 'x': case 'X':
        !           286:                                pr->flags = F_UINT;
        !           287: sw1:                           switch(fu->bcnt) {
        !           288:                                case 0: case 4:
        !           289:                                        pr->bcnt = 4;
        !           290:                                        break;
        !           291:                                case 1:
        !           292:                                        pr->bcnt = 1;
        !           293:                                        break;
        !           294:                                case 2:
        !           295:                                        pr->bcnt = 2;
        !           296:                                        break;
        !           297:                                default:
        !           298:                                        p1[1] = '\0';
        !           299:                                        badcnt(p1);
        !           300:                                }
        !           301:                                break;
        !           302:                        case 'e': case 'E': case 'f': case 'g': case 'G':
        !           303:                                pr->flags = F_DBL;
        !           304:                                switch(fu->bcnt) {
        !           305:                                case 0: case 8:
        !           306:                                        pr->bcnt = 8;
        !           307:                                        break;
        !           308:                                case 4:
        !           309:                                        pr->bcnt = 4;
        !           310:                                        break;
        !           311:                                default:
        !           312:                                        p1[1] = '\0';
        !           313:                                        badcnt(p1);
        !           314:                                }
        !           315:                                break;
        !           316:                        case 's':
        !           317:                                pr->flags = F_STR;
        !           318:                                switch(sokay) {
        !           319:                                case NOTOKAY:
        !           320:                                        badsfmt();
        !           321:                                case USEBCNT:
        !           322:                                        pr->bcnt = fu->bcnt;
        !           323:                                        break;
        !           324:                                case USEPREC:
        !           325:                                        pr->bcnt = prec;
        !           326:                                        break;
        !           327:                                }
        !           328:                                break;
        !           329:                        case '_':
        !           330:                                ++p2;
        !           331:                                switch(p1[1]) {
        !           332:                                case 'A':
        !           333:                                        endfu = fu;
        !           334:                                        fu->flags |= F_IGNORE;
        !           335:                                        /* FALLTHROUGH */
        !           336:                                case 'a':
        !           337:                                        pr->flags = F_ADDRESS;
        !           338:                                        ++p2;
        !           339:                                        switch(p1[2]) {
        !           340:                                        case 'd': case 'o': case'x':
        !           341:                                                *p1 = p1[2];
        !           342:                                                break;
        !           343:                                        default:
        !           344:                                                p1[3] = '\0';
        !           345:                                                badconv(p1);
        !           346:                                        }
        !           347:                                        break;
        !           348:                                case 'c':
        !           349:                                        pr->flags = F_C;
        !           350:                                        /* *p1 = 'c';   set in conv_c */
        !           351:                                        goto sw2;
        !           352:                                case 'p':
        !           353:                                        pr->flags = F_P;
        !           354:                                        *p1 = 'c';
        !           355:                                        goto sw2;
        !           356:                                case 'u':
        !           357:                                        pr->flags = F_U;
        !           358:                                        /* *p1 = 'c';   set in conv_u */
        !           359: sw2:                                   switch(fu->bcnt) {
        !           360:                                        case 0: case 1:
        !           361:                                                pr->bcnt = 1;
        !           362:                                                break;
        !           363:                                        default:
        !           364:                                                p1[2] = '\0';
        !           365:                                                badcnt(p1);
        !           366:                                        }
        !           367:                                        break;
        !           368:                                default:
        !           369:                                        p1[2] = '\0';
        !           370:                                        badconv(p1);
        !           371:                                }
        !           372:                                break;
        !           373:                        default:
        !           374:                                p1[1] = '\0';
        !           375:                                badconv(p1);
        !           376:                        }
        !           377: 
        !           378:                        /*
        !           379:                         * copy to PR format string, set conversion character
        !           380:                         * pointer, update original.
        !           381:                         */
        !           382:                        savech = *p2;
        !           383:                        p1[1] = '\0';
        !           384:                        if (!(pr->fmt = strdup(fmtp)))
        !           385:                                nomem();
        !           386:                        *p2 = savech;
        !           387:                        pr->cchar = pr->fmt + (p1 - fmtp);
        !           388:                        fmtp = p2;
        !           389: 
        !           390:                        /* only one conversion character if byte count */
        !           391:                        if (!(pr->flags&F_ADDRESS) && fu->bcnt && nconv++) {
        !           392:                                (void)fprintf(stderr,
        !           393:                                    "hexdump: byte count with multiple conversion characters.\n");
        !           394:                                exit(1);
        !           395:                        }
        !           396:                }
        !           397:                /*
        !           398:                 * if format unit byte count not specified, figure it out
        !           399:                 * so can adjust rep count later.
        !           400:                 */
        !           401:                if (!fu->bcnt)
        !           402:                        for (pr = fu->nextpr; pr; pr = pr->nextpr)
        !           403:                                fu->bcnt += pr->bcnt;
        !           404:        }
        !           405:        /*
        !           406:         * if the format string interprets any data at all, and it's
        !           407:         * not the same as the blocksize, and its last format unit
        !           408:         * interprets any data at all, and has no iteration count,
        !           409:         * repeat it as necessary.
        !           410:         *
        !           411:         * if, rep count is greater than 1, no trailing whitespace
        !           412:         * gets output from the last iteration of the format unit.
        !           413:         */
        !           414:        for (fu = fs->nextfu;; fu = fu->nextfu) {
        !           415:                if (!fu->nextfu && fs->bcnt < blocksize &&
        !           416:                    !(fu->flags&F_SETREP) && fu->bcnt)
        !           417:                        fu->reps += (blocksize - fs->bcnt) / fu->bcnt;
        !           418:                if (fu->reps > 1) {
        !           419:                        for (pr = fu->nextpr;; pr = pr->nextpr)
        !           420:                                if (!pr->nextpr)
        !           421:                                        break;
        !           422:                        for (p1 = pr->fmt, p2 = NULL; *p1; ++p1)
        !           423:                                p2 = isspace(*p1) ? p1 : NULL;
        !           424:                        if (p2)
        !           425:                                pr->nospace = p2;
        !           426:                }
        !           427:                if (!fu->nextfu)
        !           428:                        break;
        !           429:        }
        !           430: }
        !           431: 
        !           432: 
        !           433: escape(p1)
        !           434:        register char *p1;
        !           435: {
        !           436:        register char *p2;
        !           437: 
        !           438:        /* alphabetic escape sequences have to be done in place */
        !           439:        for (p2 = p1;; ++p1, ++p2) {
        !           440:                if (!*p1) {
        !           441:                        *p2 = *p1;
        !           442:                        break;
        !           443:                }
        !           444:                if (*p1 == '\\')
        !           445:                        switch(*++p1) {
        !           446:                        case 'a':
        !           447:                             /* *p2 = '\a'; */
        !           448:                                *p2 = '\007';
        !           449:                                break;
        !           450:                        case 'b':
        !           451:                                *p2 = '\b';
        !           452:                                break;
        !           453:                        case 'f':
        !           454:                                *p2 = '\f';
        !           455:                                break;
        !           456:                        case 'n':
        !           457:                                *p2 = '\n';
        !           458:                                break;
        !           459:                        case 'r':
        !           460:                                *p2 = '\r';
        !           461:                                break;
        !           462:                        case 't':
        !           463:                                *p2 = '\t';
        !           464:                                break;
        !           465:                        case 'v':
        !           466:                                *p2 = '\v';
        !           467:                                break;
        !           468:                        default:
        !           469:                                *p2 = *p1;
        !           470:                                break;
        !           471:                        }
        !           472:        }
        !           473: }
        !           474: 
        !           475: badcnt(s)
        !           476:        char *s;
        !           477: {
        !           478:        (void)fprintf(stderr,
        !           479:            "hexdump: bad byte count for conversion character %s.\n", s);
        !           480:        exit(1);
        !           481: }
        !           482: 
        !           483: badsfmt()
        !           484: {
        !           485:        (void)fprintf(stderr,
        !           486:            "hexdump: %%s requires a precision or a byte count.\n");
        !           487:        exit(1);
        !           488: }
        !           489: 
        !           490: badfmt(fmt)
        !           491:        char *fmt;
        !           492: {
        !           493:        (void)fprintf(stderr, "hexdump: bad format {%s}\n", fmt);
        !           494:        exit(1);
        !           495: }
        !           496: 
        !           497: badconv(ch)
        !           498:        char *ch;
        !           499: {
        !           500:        (void)fprintf(stderr, "hexdump: bad conversion character %%%s.\n", ch);
        !           501:        exit(1);
        !           502: }

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