Return to rs.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / tools / src

Annotation of 43BSD/contrib/tools/src/rs.c, revision 1.1

1.1     ! root        1: /* Copyright (c) 1983 Regents of the University of California */
        !             2: 
        !             3: #ifndef lint
        !             4: static char sccsid[] = "@(#)rs.c       4.3     (Berkeley)      4/5/86";
        !             5: #endif not lint
        !             6: 
        !             7: /*
        !             8:  *     rs - reshape a data array
        !             9:  *     Author:  John Kunze, Office of Comp. Affairs, UCB
        !            10:  *             BEWARE: lots of unfinished edges
        !            11:  */
        !            12: 
        !            13: #include <stdio.h>
        !            14: #include <ctype.h>
        !            15: 
        !            16: long   flags;
        !            17: #define        TRANSPOSE       000001
        !            18: #define        MTRANSPOSE      000002
        !            19: #define        ONEPERLINE      000004
        !            20: #define        ONEISEPONLY     000010
        !            21: #define        ONEOSEPONLY     000020
        !            22: #define        NOTRIMENDCOL    000040
        !            23: #define        SQUEEZE         000100
        !            24: #define        SHAPEONLY       000200
        !            25: #define        DETAILSHAPE     000400
        !            26: #define        RIGHTADJUST     001000
        !            27: #define        NULLPAD         002000
        !            28: #define        RECYCLE         004000
        !            29: #define        SKIPPRINT       010000
        !            30: #define        ICOLBOUNDS      020000
        !            31: #define        OCOLBOUNDS      040000
        !            32: #define ONEPERCHAR     0100000
        !            33: #define NOARGS         0200000
        !            34: 
        !            35: char   buf[BUFSIZ];
        !            36: short  *colwidths;
        !            37: short  *cord;
        !            38: short  *icbd;
        !            39: short  *ocbd;
        !            40: int    nelem;
        !            41: char   **elem;
        !            42: char   **endelem;
        !            43: char   *curline;
        !            44: int    allocsize = BUFSIZ;
        !            45: int    curlen;
        !            46: int    irows, icols;
        !            47: int    orows, ocols;
        !            48: int    maxlen;
        !            49: int    skip;
        !            50: int    propgutter;
        !            51: char   isep = ' ', osep = ' ';
        !            52: int    owidth = 80, gutter = 2;
        !            53: 
        !            54: char   **getptrs();
        !            55: 
        !            56: main(argc, argv)
        !            57: int    argc;
        !            58: char   **argv;
        !            59: {
        !            60:        setbuf(stdout, buf);
        !            61:        getargs(argc, argv);
        !            62:        getfile();
        !            63:        if (flags & SHAPEONLY) {
        !            64:                printf("%d %d\n", irows, icols);
        !            65:                exit(0);
        !            66:        }
        !            67:        prepfile();
        !            68:        /*fprintf(stderr, "#irows %d icols %d orows %d ocols %d\n",irows,icols,orows,ocols);*/
        !            69:        putfile();
        !            70:        exit(0);
        !            71: }
        !            72: 
        !            73: getfile()
        !            74: {
        !            75:        register char   *p;
        !            76:        register char   *endp;
        !            77:        register char   **ep = 0;
        !            78:        int     multisep = (flags & ONEISEPONLY ? 0 : 1);
        !            79:        int     nullpad = flags & NULLPAD;
        !            80:        char    **padto;
        !            81: 
        !            82:        while (skip--) {
        !            83:                getline();
        !            84:                if (flags & SKIPPRINT)
        !            85:                        puts(curline);
        !            86:        }
        !            87:        getline();
        !            88:        if (flags & NOARGS && curlen < owidth)
        !            89:                flags |= ONEPERLINE;
        !            90:        if (flags & ONEPERLINE)
        !            91:                icols = 1;
        !            92:        else                            /* count cols on first line */
        !            93:                for (p = curline, endp = curline + curlen; p < endp; p++) {
        !            94:                        if (*p == isep && multisep)
        !            95:                                continue;
        !            96:                        icols++;
        !            97:                        while (*p && *p != isep)
        !            98:                                p++;
        !            99:                }
        !           100:        ep = getptrs(elem);
        !           101:        p = curline;
        !           102:        do {
        !           103:                if (flags & ONEPERLINE) {
        !           104:                        *ep++ = curline;
        !           105:                        if (maxlen < curlen)
        !           106:                                maxlen = curlen;
        !           107:                        irows++;
        !           108:                        continue;
        !           109:                }
        !           110:                for (p = curline, endp = curline + curlen; p < endp; p++) {
        !           111:                        if (*p == isep && multisep)
        !           112:                                continue;       /* eat up column separators */
        !           113:                        if (*p == isep)         /* must be an empty column */
        !           114:                                *ep = "";
        !           115:                        else                    /* store column entry */
        !           116:                                *ep = p;
        !           117:                        while (p < endp && *p != isep)
        !           118:                                p++;            /* find end of entry */
        !           119:                        *p = '\0';              /* mark end of entry */
        !           120:                        if (maxlen < p - *ep)   /* update maxlen */
        !           121:                                maxlen = p - *ep;
        !           122:                        ep++;                   /* prepare for next entry */
        !           123:                }
        !           124:                irows++;                        /* update row count */
        !           125:                if (nullpad) {                  /* pad missing entries */
        !           126:                        padto = elem + irows * icols;
        !           127:                        while  (ep < padto)
        !           128:                                *ep++ = "";
        !           129:                }
        !           130:        if (ep > endelem)                       /* if low on pointers */
        !           131:                ep = getptrs(ep);               /* get some more */
        !           132:        } while (getline() != EOF);
        !           133:        *ep = 0;                                /* mark end of pointers */
        !           134:        nelem = ep - elem;
        !           135: }
        !           136: 
        !           137: putfile()
        !           138: {
        !           139:        register char   **ep;
        !           140:        register int    i;
        !           141:        register int    j;
        !           142: 
        !           143:        ep = elem;
        !           144:        if (flags & TRANSPOSE)
        !           145:                for (i = 0; i < orows; i++) {
        !           146:                        for (j = i; j < nelem; j += orows)
        !           147:                                prints(ep[j], (j - i) / orows);
        !           148:                        putchar('\n');
        !           149:                }
        !           150:        else
        !           151:                for (i = 0; i < orows; i++) {
        !           152:                        for (j = 0; j < ocols; j++)
        !           153:                                prints(*ep++, j);
        !           154:                        putchar('\n');
        !           155:                }
        !           156: }
        !           157: 
        !           158: prints(s, col)
        !           159: char   *s;
        !           160: int    col;
        !           161: {
        !           162:        register char   *p = s;
        !           163:        register int    n;
        !           164: 
        !           165:        while (*p)
        !           166:                p++;
        !           167:        n = (flags & ONEOSEPONLY ? 1 : colwidths[col] - (p - s));
        !           168:        if (flags & RIGHTADJUST)
        !           169:                while (n-- > 0)
        !           170:                        putchar(osep);
        !           171:        for (p = s; *p; p++)
        !           172:                putchar(*p);
        !           173:        while (n-- > 0)
        !           174:                putchar(osep);
        !           175: }
        !           176: 
        !           177: error(msg, s)
        !           178: char   *msg;
        !           179: char   *s;
        !           180: {
        !           181:        fprintf(stderr, "rs:  ");
        !           182:        fprintf(stderr, msg, s);
        !           183:        fprintf(stderr, "\nUsage:  rs [ -[csCS][x][kKgGw][N]tTeEnyjhHm ] [ rows [ cols ] ]\n");
        !           184:        exit(1);
        !           185: }
        !           186: 
        !           187: prepfile()
        !           188: {
        !           189:        register char   **ep;
        !           190:        register int    i;
        !           191:        register int    j;
        !           192:        char    **lp;
        !           193:        int     colw;
        !           194:        int     max = 0;
        !           195:        int     n;
        !           196: 
        !           197:        if (!nelem)
        !           198:                exit(0);
        !           199:        gutter += maxlen * propgutter / 100.0;
        !           200:        colw = maxlen + gutter;
        !           201:        if (flags & MTRANSPOSE) {
        !           202:                orows = icols;
        !           203:                ocols = irows;
        !           204:        }
        !           205:        else if (orows == 0 && ocols == 0) {    /* decide rows and cols */
        !           206:                ocols = owidth / colw;
        !           207:                if (ocols == 0)
        !           208:                        fprintf(stderr, "Display width %d is less than column width %d\n", owidth, colw);
        !           209:                if (ocols > nelem)
        !           210:                        ocols = nelem;
        !           211:                orows = nelem / ocols + (nelem % ocols ? 1 : 0);
        !           212:        }
        !           213:        else if (orows == 0)                    /* decide on rows */
        !           214:                orows = nelem / ocols + (nelem % ocols ? 1 : 0);
        !           215:        else if (ocols == 0)                    /* decide on cols */
        !           216:                ocols = nelem / orows + (nelem % orows ? 1 : 0);
        !           217:        lp = elem + orows * ocols;
        !           218:        while (lp > endelem) {
        !           219:                getptrs(elem + nelem);
        !           220:                lp = elem + orows * ocols;
        !           221:        }
        !           222:        if (flags & RECYCLE) {
        !           223:                for (ep = elem + nelem; ep < lp; ep++)
        !           224:                        *ep = *(ep - nelem);
        !           225:                nelem = lp - elem;
        !           226:        }
        !           227:        if (!(colwidths = (short *) malloc(ocols * sizeof(short))))
        !           228:                error("malloc:  No gutter space", "");
        !           229:        if (flags & SQUEEZE) {
        !           230:                if (flags & TRANSPOSE)
        !           231:                        for (ep = elem, i = 0; i < ocols; i++) {
        !           232:                                for (j = 0; j < orows; j++)
        !           233:                                        if ((n = strlen(*ep++)) > max)
        !           234:                                                max = n;
        !           235:                                colwidths[i] = max + gutter;
        !           236:                        }
        !           237:                else
        !           238:                        for (i = 0; i < ocols; i++) {
        !           239:                                for (j = i; j < nelem; j += ocols)
        !           240:                                        if ((n = strlen(ep[j])) > max)
        !           241:                                                max = n;
        !           242:                                colwidths[i] = max + gutter;
        !           243:                        }
        !           244:        }
        !           245:        /*      for (i = 0; i < orows; i++) {
        !           246:                        for (j = i; j < nelem; j += orows)
        !           247:                                prints(ep[j], (j - i) / orows);
        !           248:                        putchar('\n');
        !           249:                }
        !           250:        else
        !           251:                for (i = 0; i < orows; i++) {
        !           252:                        for (j = 0; j < ocols; j++)
        !           253:                                prints(*ep++, j);
        !           254:                        putchar('\n');
        !           255:                }*/
        !           256:        else
        !           257:                for (i = 0; i < ocols; i++)
        !           258:                        colwidths[i] = colw;
        !           259:        if (!(flags & NOTRIMENDCOL)) {
        !           260:                if (flags & RIGHTADJUST)
        !           261:                        colwidths[0] -= gutter;
        !           262:                else
        !           263:                        colwidths[ocols - 1] = 0;
        !           264:        }
        !           265:        n = orows * ocols;
        !           266:        if (n > nelem && (flags & RECYCLE))
        !           267:                nelem = n;
        !           268:        /*for (i = 0; i < ocols; i++)
        !           269:                fprintf(stderr, "%d ",colwidths[i]);
        !           270:        fprintf(stderr, "is colwidths, nelem %d\n", nelem);*/
        !           271: }
        !           272: 
        !           273: #define        BSIZE   2048
        !           274: char   ibuf[BSIZE];            /* two screenfuls should do */
        !           275: 
        !           276: getline()      /* get line; maintain curline, curlen; manage storage */
        !           277: {
        !           278:        register char   *p;
        !           279:        register int    c;
        !           280:        register int    i;
        !           281:        static  int     putlength;
        !           282:        static  char    *endblock = ibuf + BSIZE;
        !           283: 
        !           284:        if (!irows) {
        !           285:                curline = ibuf;
        !           286:                putlength = flags & DETAILSHAPE;
        !           287:        }
        !           288:        else if (skip <= 0) {                   /* don't waste storage */
        !           289:                curline += curlen + 1;
        !           290:                if (putlength)          /* print length, recycle storage */
        !           291:                        printf(" %d line %d\n", curlen, irows);
        !           292:        }
        !           293:        if (!putlength && endblock - curline < BUFSIZ) {   /* need storage */
        !           294:                /*ww = endblock-curline; tt += ww;*/
        !           295:                /*printf("#wasted %d total %d\n",ww,tt);*/
        !           296:                if (!(curline = (char *) malloc(BSIZE)))
        !           297:                        error("File too large", "");
        !           298:                endblock = curline + BSIZE;
        !           299:                /*printf("#endb %d curline %d\n",endblock,curline);*/
        !           300:        }
        !           301:        for (p = curline, i = 1; i < BUFSIZ; *p++ = c, i++)
        !           302:                if ((c = getchar()) == EOF || c == '\n')
        !           303:                        break;
        !           304:        *p = '\0';
        !           305:        curlen = i - 1;
        !           306:        return(c);
        !           307: }
        !           308: 
        !           309: char   **
        !           310: getptrs(sp)
        !           311: char   **sp;
        !           312: {
        !           313:        register char   **p;
        !           314:        register char   **ep;
        !           315: 
        !           316:        for (;;) {
        !           317:                allocsize += allocsize;
        !           318:                if (!(p = (char **) malloc(allocsize * sizeof(char *)))) {
        !           319:                        perror("rs");
        !           320:                        exit(1);
        !           321:                }
        !           322:                if ((endelem = p + allocsize - icols) <= p) {
        !           323:                        free(p);
        !           324:                        continue;
        !           325:                }
        !           326:                if (elem != 0)
        !           327:                        free(elem);
        !           328:                ep = elem;
        !           329:                elem = p;
        !           330:                while (ep < sp)
        !           331:                        *p++ = *ep++;
        !           332:                return(p);
        !           333:        }
        !           334: }
        !           335: 
        !           336: getargs(ac, av)
        !           337: int    ac;
        !           338: char   **av;
        !           339: {
        !           340:        register char   *p;
        !           341:        char    *getnum(), *getlist();
        !           342: 
        !           343:        if (ac == 1) {
        !           344:                flags |= NOARGS | TRANSPOSE;
        !           345:        }
        !           346:        while (--ac && **++av == '-')
        !           347:                for (p = *av+1; *p; p++)
        !           348:                        switch (*p) {
        !           349:                        case 'T':
        !           350:                                flags |= MTRANSPOSE;
        !           351:                        case 't':
        !           352:                                flags |= TRANSPOSE;
        !           353:                                break;
        !           354:                        case 'c':               /* input col. separator */
        !           355:                                flags |= ONEISEPONLY;
        !           356:                        case 's':               /* one or more allowed */
        !           357:                                if (p[1])
        !           358:                                        isep = *++p;
        !           359:                                else
        !           360:                                        isep = '\t';    /* default is ^I */
        !           361:                                break;
        !           362:                        case 'C':
        !           363:                                flags |= ONEOSEPONLY;
        !           364:                        case 'S':
        !           365:                                if (p[1])
        !           366:                                        osep = *++p;
        !           367:                                else
        !           368:                                        osep = '\t';    /* default is ^I */
        !           369:                                break;
        !           370:                        case 'w':               /* window width, default 80 */
        !           371:                                p = getnum(&owidth, p, 0);
        !           372:                                if (owidth <= 0)
        !           373:                                        error("Width must be a positive integer", "");
        !           374:                                break;
        !           375:                        case 'K':                       /* skip N lines */
        !           376:                                flags |= SKIPPRINT;
        !           377:                        case 'k':                       /* skip, do not print */
        !           378:                                p = getnum(&skip, p, 0);
        !           379:                                if (!skip)
        !           380:                                        skip = 1;
        !           381:                                break;
        !           382:                        case 'm':
        !           383:                                flags |= NOTRIMENDCOL;
        !           384:                                break;
        !           385:                        case 'g':               /* gutter space */
        !           386:                                p = getnum(&gutter, p, 0);
        !           387:                                break;
        !           388:                        case 'G':
        !           389:                                p = getnum(&propgutter, p, 0);
        !           390:                                break;
        !           391:                        case 'e':               /* each line is an entry */
        !           392:                                flags |= ONEPERLINE;
        !           393:                                break;
        !           394:                        case 'E':
        !           395:                                flags |= ONEPERCHAR;
        !           396:                                break;
        !           397:                        case 'j':                       /* right adjust */
        !           398:                                flags |= RIGHTADJUST;
        !           399:                                break;
        !           400:                        case 'n':       /* null padding for missing values */
        !           401:                                flags |= NULLPAD;
        !           402:                                break;
        !           403:                        case 'y':
        !           404:                                flags |= RECYCLE;
        !           405:                                break;
        !           406:                        case 'H':                       /* print shape only */
        !           407:                                flags |= DETAILSHAPE;
        !           408:                        case 'h':
        !           409:                                flags |= SHAPEONLY;
        !           410:                                break;
        !           411:                        case 'z':                       /* squeeze col width */
        !           412:                                flags |= SQUEEZE;
        !           413:                                break;
        !           414:                        /*case 'p':
        !           415:                                ipagespace = atoi(++p); (default is 1)
        !           416:                                break;*/
        !           417:                        case 'o':                       /* col order */
        !           418:                                p = getlist(&cord, p);
        !           419:                                break;
        !           420:                        case 'b':
        !           421:                                flags |= ICOLBOUNDS;
        !           422:                                p = getlist(&icbd, p);
        !           423:                                break;
        !           424:                        case 'B':
        !           425:                                flags |= OCOLBOUNDS;
        !           426:                                p = getlist(&ocbd, p);
        !           427:                                break;
        !           428:                        default:
        !           429:                                error("Bad flag:  %.1s", p);
        !           430:                        }
        !           431:        /*if (!osep)
        !           432:                osep = isep;*/
        !           433:        switch (ac) {
        !           434:        /*case 3:
        !           435:                opages = atoi(av[2]);*/
        !           436:        case 2:
        !           437:                ocols = atoi(av[1]);
        !           438:        case 1:
        !           439:                orows = atoi(av[0]);
        !           440:        case 0:
        !           441:                break;
        !           442:        default:
        !           443:                error("Too many arguments.  What do you mean by `%s'?", av[3]);
        !           444:        }
        !           445: }
        !           446: 
        !           447: char   *
        !           448: getlist(list, p)
        !           449: short  **list;
        !           450: char   *p;
        !           451: {
        !           452:        register char   *t;
        !           453:        register int    count = 1;
        !           454: 
        !           455:        for (t = p + 1; *t; t++) {
        !           456:                if (!isdigit(*t))
        !           457:                        error("Option %.1s requires a list of unsigned numbers separated by commas", t);
        !           458:                count++;
        !           459:                while (*t && isdigit(*t))
        !           460:                        t++;
        !           461:                if (*t != ',')
        !           462:                        break;
        !           463:        }
        !           464:        if (!(*list = (short *) malloc(count * sizeof(short))))
        !           465:                error("No list space", "");
        !           466:        count = 0;
        !           467:        for (t = p + 1; *t; t++) {
        !           468:                (*list)[count++] = atoi(t);
        !           469:                printf("++ %d ", (*list)[count-1]);
        !           470:                fflush(stdout);
        !           471:                while (*t && isdigit(*t))
        !           472:                        t++;
        !           473:                if (*t != ',')
        !           474:                        break;
        !           475:        }
        !           476:        (*list)[count] = 0;
        !           477:        return(t - 1);
        !           478: }
        !           479: 
        !           480: char   *
        !           481: getnum(num, p, strict) /* num = number p points to; if (strict) complain */
        !           482: int    *num;                           /* returns pointer to end of num */
        !           483: char   *p;
        !           484: int    strict;
        !           485: {
        !           486:        register char   *t = p;
        !           487: 
        !           488:        if (!isdigit(*++t)) {
        !           489:                if (strict || *t == '-' || *t == '+')
        !           490:                        error("Option %.1s requires an unsigned integer", p);
        !           491:                *num = 0;
        !           492:                return(p);
        !           493:        }
        !           494:        *num = atoi(t);
        !           495:        while (*++t)
        !           496:                if (!isdigit(*t))
        !           497:                        break;
        !           498:        return(--t);
        !           499: }

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