source: branches/3.2/mindi-busybox/libbb/dump.c @ 3232

Last change on this file since 3232 was 3232, checked in by bruno, 5 years ago
  • Update mindi-busybox to 1.21.1
File size: 19.8 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * Support code for the hexdump and od applets,
4 * based on code from util-linux v 2.11l
5 *
6 * Copyright (c) 1989
7 * The Regents of the University of California.  All rights reserved.
8 *
9 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
10 *
11 * Original copyright notice is retained at the end of this file.
12 */
13
14#include "libbb.h"
15#include "dump.h"
16
17static const char index_str[] ALIGN1 = ".#-+ 0123456789";
18
19static const char size_conv_str[] ALIGN1 =
20"\x1\x4\x4\x4\x4\x4\x4\x8\x8\x8\x8\010cdiouxXeEfgG";
21
22static const char lcc[] ALIGN1 = "diouxX";
23
24
25typedef struct priv_dumper_t {
26    dumper_t pub;
27
28    char **argv;
29    FU *endfu;
30    off_t savaddress;        /* saved address/offset in stream */
31    off_t eaddress;          /* end address */
32    off_t address;           /* address/offset in stream */
33    int blocksize;
34    smallint exitval;        /* final exit value */
35
36    /* former statics */
37    smallint next__done;
38    smallint get__ateof; // = 1;
39    unsigned char *get__curp;
40    unsigned char *get__savp;
41} priv_dumper_t;
42
43dumper_t* FAST_FUNC alloc_dumper(void)
44{
45    priv_dumper_t *dumper = xzalloc(sizeof(*dumper));
46    dumper->pub.dump_length = -1;
47    dumper->pub.dump_vflag = FIRST;
48    dumper->get__ateof = 1;
49    return &dumper->pub;
50}
51
52
53static NOINLINE int bb_dump_size(FS *fs)
54{
55    FU *fu;
56    int bcnt, cur_size;
57    char *fmt;
58    const char *p;
59    int prec;
60
61    /* figure out the data block bb_dump_size needed for each format unit */
62    for (cur_size = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {
63        if (fu->bcnt) {
64            cur_size += fu->bcnt * fu->reps;
65            continue;
66        }
67        for (bcnt = prec = 0, fmt = fu->fmt; *fmt; ++fmt) {
68            if (*fmt != '%')
69                continue;
70            /*
71             * skip any special chars -- save precision in
72             * case it's a %s format.
73             */
74            while (strchr(index_str + 1, *++fmt))
75                continue;
76            if (*fmt == '.' && isdigit(*++fmt)) {
77                prec = atoi(fmt);
78                while (isdigit(*++fmt))
79                    continue;
80            }
81            p = strchr(size_conv_str + 12, *fmt);
82            if (!p) {
83                if (*fmt == 's') {
84                    bcnt += prec;
85                } else if (*fmt == '_') {
86                    ++fmt;
87                    if ((*fmt == 'c') || (*fmt == 'p') || (*fmt == 'u')) {
88                        bcnt += 1;
89                    }
90                }
91            } else {
92                bcnt += size_conv_str[p - (size_conv_str + 12)];
93            }
94        }
95        cur_size += bcnt * fu->reps;
96    }
97    return cur_size;
98}
99
100static NOINLINE void rewrite(priv_dumper_t *dumper, FS *fs)
101{
102    enum { NOTOKAY, USEBCNT, USEPREC } sokay;
103    FU *fu;
104    PR *pr;
105    char *p1, *p2, *p3;
106    char savech, *fmtp;
107    const char *byte_count_str;
108    int nconv, prec = 0;
109
110    for (fu = fs->nextfu; fu; fu = fu->nextfu) {
111        /*
112         * break each format unit into print units; each
113         * conversion character gets its own.
114         */
115        for (nconv = 0, fmtp = fu->fmt; *fmtp; ) {
116            /* NOSTRICT */
117            /* DBU:[dvae@cray.com] zalloc so that forward ptrs start out NULL*/
118            pr = xzalloc(sizeof(PR));
119            if (!fu->nextpr)
120                fu->nextpr = pr;
121
122            /* skip preceding text and up to the next % sign */
123            for (p1 = fmtp; *p1 && *p1 != '%'; ++p1)
124                continue;
125
126            /* only text in the string */
127            if (!*p1) {
128                pr->fmt = fmtp;
129                pr->flags = F_TEXT;
130                break;
131            }
132
133            /*
134             * get precision for %s -- if have a byte count, don't
135             * need it.
136             */
137            if (fu->bcnt) {
138                sokay = USEBCNT;
139                /* skip to conversion character */
140                for (++p1; strchr(index_str, *p1); ++p1)
141                    continue;
142            } else {
143                /* skip any special chars, field width */
144                while (strchr(index_str + 1, *++p1))
145                    continue;
146                if (*p1 == '.' && isdigit(*++p1)) {
147                    sokay = USEPREC;
148                    prec = atoi(p1);
149                    while (isdigit(*++p1))
150                        continue;
151                } else
152                    sokay = NOTOKAY;
153            }
154
155            p2 = p1 + 1; /* set end pointer */
156
157            /*
158             * figure out the byte count for each conversion;
159             * rewrite the format as necessary, set up blank-
160             * pbb_dump_adding for end of data.
161             */
162            if (*p1 == 'c') {
163                pr->flags = F_CHAR;
164 DO_BYTE_COUNT_1:
165                byte_count_str = "\001";
166 DO_BYTE_COUNT:
167                if (fu->bcnt) {
168                    do {
169                        if (fu->bcnt == *byte_count_str) {
170                            break;
171                        }
172                    } while (*++byte_count_str);
173                }
174                /* Unlike the original, output the remainder of the format string. */
175                if (!*byte_count_str) {
176                    bb_error_msg_and_die("bad byte count for conversion character %s", p1);
177                }
178                pr->bcnt = *byte_count_str;
179            } else if (*p1 == 'l') {
180                ++p2;
181                ++p1;
182 DO_INT_CONV:
183                {
184                    const char *e;
185                    e = strchr(lcc, *p1);
186                    if (!e) {
187                        goto DO_BAD_CONV_CHAR;
188                    }
189                    pr->flags = F_INT;
190                    if (e > lcc + 1) {
191                        pr->flags = F_UINT;
192                    }
193                    byte_count_str = "\004\002\001";
194                    goto DO_BYTE_COUNT;
195                }
196                /* NOTREACHED */
197            } else if (strchr(lcc, *p1)) {
198                goto DO_INT_CONV;
199            } else if (strchr("eEfgG", *p1)) {
200                pr->flags = F_DBL;
201                byte_count_str = "\010\004";
202                goto DO_BYTE_COUNT;
203            } else if (*p1 == 's') {
204                pr->flags = F_STR;
205                if (sokay == USEBCNT) {
206                    pr->bcnt = fu->bcnt;
207                } else if (sokay == USEPREC) {
208                    pr->bcnt = prec;
209                } else {   /* NOTOKAY */
210                    bb_error_msg_and_die("%%s requires a precision or a byte count");
211                }
212            } else if (*p1 == '_') {
213                ++p2;
214                switch (p1[1]) {
215                case 'A':
216                    dumper->endfu = fu;
217                    fu->flags |= F_IGNORE;
218                    /* FALLTHROUGH */
219                case 'a':
220                    pr->flags = F_ADDRESS;
221                    ++p2;
222                    if ((p1[2] != 'd') && (p1[2] != 'o') && (p1[2] != 'x')) {
223                        goto DO_BAD_CONV_CHAR;
224                    }
225                    *p1 = p1[2];
226                    break;
227                case 'c':
228                    pr->flags = F_C;
229                    /* *p1 = 'c';   set in conv_c */
230                    goto DO_BYTE_COUNT_1;
231                case 'p':
232                    pr->flags = F_P;
233                    *p1 = 'c';
234                    goto DO_BYTE_COUNT_1;
235                case 'u':
236                    pr->flags = F_U;
237                    /* *p1 = 'c';   set in conv_u */
238                    goto DO_BYTE_COUNT_1;
239                default:
240                    goto DO_BAD_CONV_CHAR;
241                }
242            } else {
243 DO_BAD_CONV_CHAR:
244                bb_error_msg_and_die("bad conversion character %%%s", p1);
245            }
246
247            /*
248             * copy to PR format string, set conversion character
249             * pointer, update original.
250             */
251            savech = *p2;
252            p1[1] = '\0';
253            pr->fmt = xstrdup(fmtp);
254            *p2 = savech;
255            //Too early! xrealloc can move pr->fmt!
256            //pr->cchar = pr->fmt + (p1 - fmtp);
257
258            /* DBU:[dave@cray.com] w/o this, trailing fmt text, space is lost.
259             * Skip subsequent text and up to the next % sign and tack the
260             * additional text onto fmt: eg. if fmt is "%x is a HEX number",
261             * we lose the " is a HEX number" part of fmt.
262             */
263            for (p3 = p2; *p3 && *p3 != '%'; p3++)
264                continue;
265            if (p3 > p2) {
266                savech = *p3;
267                *p3 = '\0';
268                pr->fmt = xrealloc(pr->fmt, strlen(pr->fmt) + (p3-p2) + 1);
269                strcat(pr->fmt, p2);
270                *p3 = savech;
271                p2 = p3;
272            }
273
274            pr->cchar = pr->fmt + (p1 - fmtp);
275            fmtp = p2;
276
277            /* only one conversion character if byte count */
278            if (!(pr->flags & F_ADDRESS) && fu->bcnt && nconv++) {
279                bb_error_msg_and_die("byte count with multiple conversion characters");
280            }
281        }
282        /*
283         * if format unit byte count not specified, figure it out
284         * so can adjust rep count later.
285         */
286        if (!fu->bcnt)
287            for (pr = fu->nextpr; pr; pr = pr->nextpr)
288                fu->bcnt += pr->bcnt;
289    }
290    /*
291     * if the format string interprets any data at all, and it's
292     * not the same as the blocksize, and its last format unit
293     * interprets any data at all, and has no iteration count,
294     * repeat it as necessary.
295     *
296     * if rep count is greater than 1, no trailing whitespace
297     * gets output from the last iteration of the format unit.
298     */
299    for (fu = fs->nextfu; fu; fu = fu->nextfu) {
300        if (!fu->nextfu
301         && fs->bcnt < dumper->blocksize
302         && !(fu->flags & F_SETREP)
303         && fu->bcnt
304        ) {
305            fu->reps += (dumper->blocksize - fs->bcnt) / fu->bcnt;
306        }
307        if (fu->reps > 1 && fu->nextpr) {
308            for (pr = fu->nextpr;; pr = pr->nextpr)
309                if (!pr->nextpr)
310                    break;
311            for (p1 = pr->fmt, p2 = NULL; *p1; ++p1)
312                p2 = isspace(*p1) ? p1 : NULL;
313            if (p2)
314                pr->nospace = p2;
315        }
316        if (!fu->nextfu)
317            break;
318    }
319}
320
321static void do_skip(priv_dumper_t *dumper, const char *fname, int statok)
322{
323    struct stat sbuf;
324
325    if (statok) {
326        xfstat(STDIN_FILENO, &sbuf, fname);
327        if (!(S_ISCHR(sbuf.st_mode) || S_ISBLK(sbuf.st_mode) || S_ISFIFO(sbuf.st_mode))
328         && dumper->pub.dump_skip >= sbuf.st_size
329        ) {
330            /* If bb_dump_size valid and pub.dump_skip >= size */
331            dumper->pub.dump_skip -= sbuf.st_size;
332            dumper->address += sbuf.st_size;
333            return;
334        }
335    }
336    if (fseek(stdin, dumper->pub.dump_skip, SEEK_SET)) {
337        bb_simple_perror_msg_and_die(fname);
338    }
339    dumper->address += dumper->pub.dump_skip;
340    dumper->savaddress = dumper->address;
341    dumper->pub.dump_skip = 0;
342}
343
344static NOINLINE int next(priv_dumper_t *dumper)
345{
346    int statok;
347
348    for (;;) {
349        if (*dumper->argv) {
350            dumper->next__done = statok = 1;
351            if (!(freopen(*dumper->argv, "r", stdin))) {
352                bb_simple_perror_msg(*dumper->argv);
353                dumper->exitval = 1;
354                ++dumper->argv;
355                continue;
356            }
357        } else {
358            if (dumper->next__done)
359                return 0; /* no next file */
360            dumper->next__done = 1;
361            statok = 0;
362        }
363        if (dumper->pub.dump_skip)
364            do_skip(dumper, statok ? *dumper->argv : "stdin", statok);
365        if (*dumper->argv)
366            ++dumper->argv;
367        if (!dumper->pub.dump_skip)
368            return 1;
369    }
370    /* NOTREACHED */
371}
372
373static unsigned char *get(priv_dumper_t *dumper)
374{
375    int n;
376    int need, nread;
377    int blocksize = dumper->blocksize;
378
379    if (!dumper->get__curp) {
380        dumper->address = (off_t)0; /*DBU:[dave@cray.com] initialize,initialize..*/
381        dumper->get__curp = xmalloc(blocksize);
382        dumper->get__savp = xzalloc(blocksize); /* need to be initialized */
383    } else {
384        unsigned char *tmp = dumper->get__curp;
385        dumper->get__curp = dumper->get__savp;
386        dumper->get__savp = tmp;
387        dumper->savaddress += blocksize;
388        dumper->address = dumper->savaddress;
389    }
390    need = blocksize;
391    nread = 0;
392    while (1) {
393        /*
394         * if read the right number of bytes, or at EOF for one file,
395         * and no other files are available, zero-pad the rest of the
396         * block and set the end flag.
397         */
398        if (!dumper->pub.dump_length || (dumper->get__ateof && !next(dumper))) {
399            if (need == blocksize) {
400                return NULL;
401            }
402            if (dumper->pub.dump_vflag != ALL && !memcmp(dumper->get__curp, dumper->get__savp, nread)) {
403                if (dumper->pub.dump_vflag != DUP) {
404                    puts("*");
405                }
406                return NULL;
407            }
408            memset(dumper->get__curp + nread, 0, need);
409            dumper->eaddress = dumper->address + nread;
410            return dumper->get__curp;
411        }
412        n = fread(dumper->get__curp + nread, sizeof(unsigned char),
413                dumper->pub.dump_length == -1 ? need : MIN(dumper->pub.dump_length, need), stdin);
414        if (!n) {
415            if (ferror(stdin)) {
416                bb_simple_perror_msg(dumper->argv[-1]);
417            }
418            dumper->get__ateof = 1;
419            continue;
420        }
421        dumper->get__ateof = 0;
422        if (dumper->pub.dump_length != -1) {
423            dumper->pub.dump_length -= n;
424        }
425        need -= n;
426        if (!need) {
427            if (dumper->pub.dump_vflag == ALL || dumper->pub.dump_vflag == FIRST
428             || memcmp(dumper->get__curp, dumper->get__savp, blocksize)
429            ) {
430                if (dumper->pub.dump_vflag == DUP || dumper->pub.dump_vflag == FIRST) {
431                    dumper->pub.dump_vflag = WAIT;
432                }
433                return dumper->get__curp;
434            }
435            if (dumper->pub.dump_vflag == WAIT) {
436                puts("*");
437            }
438            dumper->pub.dump_vflag = DUP;
439            dumper->savaddress += blocksize;
440            dumper->address = dumper->savaddress;
441            need = blocksize;
442            nread = 0;
443        } else {
444            nread += n;
445        }
446    }
447}
448
449static void bpad(PR *pr)
450{
451    char *p1, *p2;
452
453    /*
454     * remove all conversion flags; '-' is the only one valid
455     * with %s, and it's not useful here.
456     */
457    pr->flags = F_BPAD;
458    *pr->cchar = 's';
459    for (p1 = pr->fmt; *p1 != '%'; ++p1)
460        continue;
461    for (p2 = ++p1; *p1 && strchr(" -0+#", *p1); ++p1)
462        if (pr->nospace)
463            pr->nospace--;
464    while ((*p2++ = *p1++) != 0)
465        continue;
466}
467
468static const char conv_str[] ALIGN1 =
469    "\0\\0\0"
470    "\007\\a\0"  /* \a */
471    "\b\\b\0"
472    "\f\\b\0"
473    "\n\\n\0"
474    "\r\\r\0"
475    "\t\\t\0"
476    "\v\\v\0"
477    ;
478
479
480static void conv_c(PR *pr, unsigned char *p)
481{
482    const char *str = conv_str;
483    char buf[10];
484
485    do {
486        if (*p == *str) {
487            ++str;
488            goto strpr;
489        }
490        str += 4;
491    } while (*str);
492
493    if (isprint_asciionly(*p)) {
494        *pr->cchar = 'c';
495        printf(pr->fmt, *p);
496    } else {
497        sprintf(buf, "%03o", (int) *p);
498        str = buf;
499 strpr:
500        *pr->cchar = 's';
501        printf(pr->fmt, str);
502    }
503}
504
505static void conv_u(PR *pr, unsigned char *p)
506{
507    static const char list[] ALIGN1 =
508        "nul\0soh\0stx\0etx\0eot\0enq\0ack\0bel\0"
509        "bs\0_ht\0_lf\0_vt\0_ff\0_cr\0_so\0_si\0_"
510        "dle\0dcl\0dc2\0dc3\0dc4\0nak\0syn\0etb\0"
511        "can\0em\0_sub\0esc\0fs\0_gs\0_rs\0_us";
512
513    /* od used nl, not lf */
514    if (*p <= 0x1f) {
515        *pr->cchar = 's';
516        printf(pr->fmt, list + (4 * (int)*p));
517    } else if (*p == 0x7f) {
518        *pr->cchar = 's';
519        printf(pr->fmt, "del");
520    } else if (*p < 0x7f) { /* isprint() */
521        *pr->cchar = 'c';
522        printf(pr->fmt, *p);
523    } else {
524        *pr->cchar = 'x';
525        printf(pr->fmt, (int) *p);
526    }
527}
528
529static void display(priv_dumper_t* dumper)
530{
531    FS *fs;
532    FU *fu;
533    PR *pr;
534    int cnt;
535    unsigned char *bp, *savebp;
536    off_t saveaddress;
537    unsigned char savech = '\0';
538
539    while ((bp = get(dumper)) != NULL) {
540        fs = dumper->pub.fshead;
541        savebp = bp;
542        saveaddress = dumper->address;
543        for (; fs; fs = fs->nextfs, bp = savebp, dumper->address = saveaddress) {
544            for (fu = fs->nextfu; fu; fu = fu->nextfu) {
545                if (fu->flags & F_IGNORE) {
546                    break;
547                }
548                for (cnt = fu->reps; cnt; --cnt) {
549                    for (pr = fu->nextpr; pr; dumper->address += pr->bcnt,
550                                bp += pr->bcnt, pr = pr->nextpr) {
551                        if (dumper->eaddress && dumper->address >= dumper->eaddress
552                         && !(pr->flags & (F_TEXT | F_BPAD))
553                        ) {
554                            bpad(pr);
555                        }
556                        if (cnt == 1 && pr->nospace) {
557                            savech = *pr->nospace;
558                            *pr->nospace = '\0';
559                        }
560/*                      PRINT; */
561                        switch (pr->flags) {
562                        case F_ADDRESS:
563                            printf(pr->fmt, (unsigned) dumper->address);
564                            break;
565                        case F_BPAD:
566                            printf(pr->fmt, "");
567                            break;
568                        case F_C:
569                            conv_c(pr, bp);
570                            break;
571                        case F_CHAR:
572                            printf(pr->fmt, *bp);
573                            break;
574                        case F_DBL: {
575                            double dval;
576                            float fval;
577
578                            switch (pr->bcnt) {
579                            case 4:
580                                memcpy(&fval, bp, sizeof(fval));
581                                printf(pr->fmt, fval);
582                                break;
583                            case 8:
584                                memcpy(&dval, bp, sizeof(dval));
585                                printf(pr->fmt, dval);
586                                break;
587                            }
588                            break;
589                        }
590                        case F_INT: {
591                            int ival;
592                            short sval;
593
594                            switch (pr->bcnt) {
595                            case 1:
596                                printf(pr->fmt, (int) *bp);
597                                break;
598                            case 2:
599                                memcpy(&sval, bp, sizeof(sval));
600                                printf(pr->fmt, (int) sval);
601                                break;
602                            case 4:
603                                memcpy(&ival, bp, sizeof(ival));
604                                printf(pr->fmt, ival);
605                                break;
606                            }
607                            break;
608                        }
609                        case F_P:
610                            printf(pr->fmt, isprint_asciionly(*bp) ? *bp : '.');
611                            break;
612                        case F_STR:
613                            printf(pr->fmt, (char *) bp);
614                            break;
615                        case F_TEXT:
616                            printf(pr->fmt);
617                            break;
618                        case F_U:
619                            conv_u(pr, bp);
620                            break;
621                        case F_UINT: {
622                            unsigned ival;
623                            unsigned short sval;
624
625                            switch (pr->bcnt) {
626                            case 1:
627                                printf(pr->fmt, (unsigned) *bp);
628                                break;
629                            case 2:
630                                memcpy(&sval, bp, sizeof(sval));
631                                printf(pr->fmt, (unsigned) sval);
632                                break;
633                            case 4:
634                                memcpy(&ival, bp, sizeof(ival));
635                                printf(pr->fmt, ival);
636                                break;
637                            }
638                            break;
639                        }
640                        }
641                        if (cnt == 1 && pr->nospace) {
642                            *pr->nospace = savech;
643                        }
644                    }
645                }
646            }
647        }
648    }
649    if (dumper->endfu) {
650        /*
651         * if eaddress not set, error or file size was multiple
652         * of blocksize, and no partial block ever found.
653         */
654        if (!dumper->eaddress) {
655            if (!dumper->address) {
656                return;
657            }
658            dumper->eaddress = dumper->address;
659        }
660        for (pr = dumper->endfu->nextpr; pr; pr = pr->nextpr) {
661            switch (pr->flags) {
662            case F_ADDRESS:
663                printf(pr->fmt, (unsigned) dumper->eaddress);
664                break;
665            case F_TEXT:
666                printf(pr->fmt);
667                break;
668            }
669        }
670    }
671}
672
673#define dumper ((priv_dumper_t*)pub_dumper)
674int FAST_FUNC bb_dump_dump(dumper_t *pub_dumper, char **argv)
675{
676    FS *tfs;
677    int blocksize;
678
679    /* figure out the data block bb_dump_size */
680    blocksize = 0;
681    tfs = dumper->pub.fshead;
682    while (tfs) {
683        tfs->bcnt = bb_dump_size(tfs);
684        if (blocksize < tfs->bcnt) {
685            blocksize = tfs->bcnt;
686        }
687        tfs = tfs->nextfs;
688    }
689    dumper->blocksize = blocksize;
690
691    /* rewrite the rules, do syntax checking */
692    for (tfs = dumper->pub.fshead; tfs; tfs = tfs->nextfs) {
693        rewrite(dumper, tfs);
694    }
695
696    dumper->argv = argv;
697    display(dumper);
698
699    return dumper->exitval;
700}
701
702void FAST_FUNC bb_dump_add(dumper_t* pub_dumper, const char *fmt)
703{
704    const char *p;
705    char *p1;
706    char *p2;
707    FS *tfs;
708    FU *tfu, **nextfupp;
709    const char *savep;
710
711    /* start new linked list of format units */
712    tfs = xzalloc(sizeof(FS)); /*DBU:[dave@cray.com] start out NULL */
713    if (!dumper->pub.fshead) {
714        dumper->pub.fshead = tfs;
715    } else {
716        FS *fslast = dumper->pub.fshead;
717        while (fslast->nextfs)
718            fslast = fslast->nextfs;
719        fslast->nextfs = tfs;
720    }
721    nextfupp = &tfs->nextfu;
722
723    /* take the format string and break it up into format units */
724    p = fmt;
725    for (;;) {
726        p = skip_whitespace(p);
727        if (*p == '\0') {
728            break;
729        }
730
731        /* allocate a new format unit and link it in */
732        /* NOSTRICT */
733        /* DBU:[dave@cray.com] zalloc so that forward pointers start out NULL */
734        tfu = xzalloc(sizeof(FU));
735        *nextfupp = tfu;
736        nextfupp = &tfu->nextfu;
737        tfu->reps = 1;
738
739        /* if leading digit, repetition count */
740        if (isdigit(*p)) {
741            for (savep = p; isdigit(*p); ++p)
742                continue;
743            if (!isspace(*p) && *p != '/') {
744                bb_error_msg_and_die("bad format {%s}", fmt);
745            }
746            /* may overwrite either white space or slash */
747            tfu->reps = atoi(savep);
748            tfu->flags = F_SETREP;
749            /* skip trailing white space */
750            p = skip_whitespace(++p);
751        }
752
753        /* skip slash and trailing white space */
754        if (*p == '/') {
755            p = skip_whitespace(p + 1);
756        }
757
758        /* byte count */
759        if (isdigit(*p)) {
760// TODO: use bb_strtou
761            savep = p;
762            while (isdigit(*++p))
763                continue;
764            if (!isspace(*p)) {
765                bb_error_msg_and_die("bad format {%s}", fmt);
766            }
767            tfu->bcnt = atoi(savep);
768            /* skip trailing white space */
769            p = skip_whitespace(p + 1);
770        }
771
772        /* format */
773        if (*p != '"') {
774            bb_error_msg_and_die("bad format {%s}", fmt);
775        }
776        for (savep = ++p; *p != '"';) {
777            if (*p++ == '\0') {
778                bb_error_msg_and_die("bad format {%s}", fmt);
779            }
780        }
781        tfu->fmt = xstrndup(savep, p - savep);
782/*      escape(tfu->fmt); */
783
784        p1 = tfu->fmt;
785
786        /* alphabetic escape sequences have to be done in place */
787        for (p2 = p1;; ++p1, ++p2) {
788            if (*p1 == '\0') {
789                *p2 = *p1;
790                break;
791            }
792            if (*p1 == '\\') {
793                const char *cs = conv_str + 4;
794                ++p1;
795                *p2 = *p1;
796                do {
797                    if (*p1 == cs[2]) {
798                        *p2 = cs[0];
799                        break;
800                    }
801                    cs += 4;
802                } while (*cs);
803            }
804        }
805
806        p++;
807    }
808}
809
810/*
811 * Copyright (c) 1989 The Regents of the University of California.
812 * All rights reserved.
813 *
814 * Redistribution and use in source and binary forms, with or without
815 * modification, are permitted provided that the following conditions
816 * are met:
817 * 1. Redistributions of source code must retain the above copyright
818 *    notice, this list of conditions and the following disclaimer.
819 * 2. Redistributions in binary form must reproduce the above copyright
820 *    notice, this list of conditions and the following disclaimer in the
821 *    documentation and/or other materials provided with the distribution.
822 * 3. Neither the name of the University nor the names of its contributors
823 *    may be used to endorse or promote products derived from this software
824 *    without specific prior written permission.
825 *
826 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
827 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
828 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
829 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
830 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
831 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
832 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
833 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
834 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
835 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
836 * SUCH DAMAGE.
837 */
Note: See TracBrowser for help on using the repository browser.